declarations

Computes the bare-specifier form of a sibling import as emitted in the rewritten .d.ts (e.g., ../models, ../../models, ./bundle/declarations).
Always omits the trailing index.d.ts so both moduleResolution: 'bundler' and node accept it.

computeSiblingSpecifier(
  '/abs/dist/libs/foo/bundle/index.d.ts',
  { srcPath: 'models', indexDtsPath: '/abs/dist/libs/foo/models/index.d.ts' }
) // => '../models'

Returns a rollup plugin that externalizes any import resolving inside a sibling entry's directory tree, rewriting the emitted specifier to a POSIX relative path stripped of /index and .d.ts suffixes.
The plugin's resolveId hook returns null for everything that does not resolve into a sibling — that lets the rest of the rollup-plugin-dts chain inline third-party type imports as before.
Self-ownership is enforced by adding the current entry into the ownership pool: when the deepest-matching entry directory is the entry being rewritten (and not a sibling), the resolver returns null so rollup keeps the path internal. This matters for the package root entry whose directory prefix- matches every other entry's path — without including self, root would spuriously claim its own subtree's files.

const plugin = createSiblingExternalizePlugin({
  selfSrcPath: 'bundle',
  selfDtsPath: '/abs/dist/libs/foo/bundle/index.d.ts',
  siblings: [{ srcPath: 'models', indexDtsPath: '/abs/dist/libs/foo/models/index.d.ts' }],
})

Joins an output base directory with an entry's srcPath to produce the absolute path of the entry's bundled index.d.ts.

dtsPathFor('/abs/dist/libs/foo', 'models') // => '/abs/dist/libs/foo/models/index.d.ts'

Convenience: filters an entry list to siblings of the supplied srcPath.

const siblings = filterSiblings('bundle', allEntries)

Returns the sibling entry whose directory contains absolutePath, or undefined when no sibling owns the path.

const owner = findOwningSibling('/abs/dist/libs/foo/models/index.d.ts', siblings)

Reshapes the nested declaration tree produced by tsc (with baseUrl=workspaceRoot) into the flat per-library structure consumers expect.
Without this step tsc emits declarations at dist/libs/<lib>/libs/<lib>/src/index.d.ts because it preserves the workspace-relative path. This primitive flattens that to dist/libs/<lib>/index.d.ts while preserving any nested platform / feature subdirectories.
The copy is recursive and unconditional, so internal non-entry subdirectories that any entry's index.d.ts re-exports from (e.g. shared/, lib/) are preserved rather than dropped. Per-source declarations left unreachable once the per-entry pass inlines each index.d.ts are removed afterwards by pruneOrphanDeclarations. Finally removes the leftover libs/, plugins/, and apps/ folders tsc created at the output root.

flattenDeclarationPaths(context)

Generates .d.ts and .d.ts.map files for every entry point in the project by spawning the workspace-local TypeScript compiler.
After tsc finishes, calls flattenDeclarationPaths to relocate the nested dist/<lib>/libs/<lib>/src/... structure that tsc emits with baseUrl=workspaceRoot back into the flat per-library shape consumers expect.

const result = await generateDeclarations(context)
console.log(result.stdout)

Removes redundant per-source .d.ts / .d.ts.map files left behind once the per-entry flatten has inlined each entry's declarations into a self-contained index.d.ts.
Walks the whole package tree (excluding _dependencies/) and deletes every declaration file not reachable from an entry-point index.d.ts via its transitive relative specifiers. Reachability — rather than a per-directory sweep — guarantees the invariant that after this runs no surviving .d.ts references a removed one: when the flatten made index.d.ts self-contained the reachable set collapses to the roots and every per-source sibling is pruned; when the flatten was skipped the siblings the public entry still re-exports (and anything they transitively re-export) stay live so the shipped types resolve. This removes the redundancy at the source so dist == the shipped tarball, demoting package.json#files to a backstop.
Safety rails:

• Never touches anything inside _dependencies/.
• A .d.ts.map is kept iff its sibling .d.ts is reachable.
• A dynamic (non-literal) import(/require( in any reached declaration

aborts the prune and keeps every declaration file.

const removed = pruneOrphanDeclarations(context)

Runs the per-entry d.ts inlining pass: re-runs rollup-plugin-dts over every tsc-emitted entry .d.ts so (a) local per-source sibling re-exports (export … from './create-logger') are flattened into the entry's index.d.ts, and (b) bundled-dep type imports are routed through _dependencies/<dep>/index.d.ts rather than left as bare specifiers. This self-containment is what lets pruneOrphanDeclarations delete the orphaned per-source .d.ts afterwards without orphaning a still-referenced sibling.
Runs whenever the build bundles any dep — npm (bundledDeps) or workspace (workspaceBundledDeps); a package whose deps are all @hyperfrontend/* still needs the flatten. Entries whose tsc output is missing are skipped silently — the bundle phase may have skipped them deliberately (e.g., empty bundles).

await runDtsPerEntry(context)

Runs the d.ts pre-pass: for each bundled dep, produces _dependencies/<dep>/index.d.ts by running rollup-plugin-dts over the dep's types entry. Cross-dep type imports are marked external so the per-entry d.ts pass can route them through _dependencies/.

await runDtsPrePass(context)

Result of running tsc to emit declaration files.

Sibling entry record consumed by createSiblingExternalizePlugin.
Each sibling represents another entry-point in the same library that has its own bundled index.d.ts. The per-entry d.ts pass externalizes imports that resolve into a sibling's directory so consumers see one canonical type surface (e.g., import type { EntryPoint } from '../models' instead of an inlined declaration in every entry).

Inputs to createSiblingExternalizePlugin.