@hyperfrontend/builder 0.1.0

package/bundle/declarations/prune-orphan-dts.d.ts

@@ -0,0 +1,33 @@
+import type { BuildContext } from '../../models';
+/**
+ * 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.
+ *
+ * @param context - Resolved build context.
+ * @returns The total number of `.d.ts` / `.d.ts.map` files removed.
+ *
+ * @example Pruning orphans after generateDeclarations
+ * ```typescript
+ * const removed = pruneOrphanDeclarations(context)
+ * ```
+ */
+export declare const pruneOrphanDeclarations: (context: BuildContext) => number;
+//# sourceMappingURL=prune-orphan-dts.d.ts.map

package/bundle/declarations/prune-orphan-dts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prune-orphan-dts.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/declarations/prune-orphan-dts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAuHhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,uBAAuB,GAAI,SAAS,YAAY,KAAG,MAoB/D,CAAA"}

package/bundle/declarations/sibling-resolver.d.ts

@@ -0,0 +1,125 @@
+import type { Plugin } from 'rollup';
+/**
+ * Sibling entry record consumed by {@link 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).
+ */
+export interface SiblingEntry {
+    /** Entry's `srcPath` (subpath under `<outputPath>`). `''` for the package root. */
+    srcPath: string;
+    /** Absolute path to the entry's bundled `index.d.ts`. */
+    indexDtsPath: string;
+}
+/**
+ * Inputs to {@link createSiblingExternalizePlugin}.
+ */
+export interface SiblingResolverInput {
+    /** `srcPath` of the entry the plugin is rewriting. */
+    selfSrcPath: string;
+    /** Absolute path to the current entry's bundled `index.d.ts`. */
+    selfDtsPath: string;
+    /** Other entries' bundled `index.d.ts` records. */
+    siblings: SiblingEntry[];
+}
+/**
+ * Returns the sibling entry whose directory contains `absolutePath`, or `undefined`
+ * when no sibling owns the path.
+ *
+ * @param absolutePath - Resolved absolute path of an import.
+ * @param siblings - Sibling-entry records.
+ * @returns Owning sibling entry, or `undefined`.
+ *
+ * @example Identifying a sibling for a resolved type import
+ * ```typescript
+ * const owner = findOwningSibling('/abs/dist/libs/foo/models/index.d.ts', siblings)
+ * ```
+ */
+export declare const findOwningSibling: (absolutePath: string, siblings: SiblingEntry[]) => SiblingEntry | undefined;
+/**
+ * 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.
+ *
+ * @param selfDtsPath - Absolute path to the current entry's `index.d.ts`.
+ * @param sibling - The sibling entry being targeted.
+ * @returns POSIX-style relative specifier ready for `id` in a rollup external resolution.
+ *
+ * @example Computing a sibling import from `bundle/index.d.ts` to `models/`
+ * ```typescript
+ * computeSiblingSpecifier(
+ *   '/abs/dist/libs/foo/bundle/index.d.ts',
+ *   { srcPath: 'models', indexDtsPath: '/abs/dist/libs/foo/models/index.d.ts' }
+ * ) // => '../models'
+ * ```
+ */
+export declare const computeSiblingSpecifier: (selfDtsPath: string, sibling: SiblingEntry) => string;
+/**
+ * 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.
+ *
+ * @param input - Self + sibling entry descriptors.
+ * @returns Rollup plugin.
+ *
+ * @example Plugin instance for the bundle entry pass
+ * ```typescript
+ * 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' }],
+ * })
+ * ```
+ */
+export declare const createSiblingExternalizePlugin: (input: SiblingResolverInput) => Plugin;
+/**
+ * Minimal entry-shape projection accepted by {@link filterSiblings}.
+ */
+export interface SiblingFilterEntry {
+    /** Entry's `srcPath`. */
+    srcPath: string;
+}
+/**
+ * Convenience: filters an entry list to siblings of the supplied `srcPath`.
+ *
+ * @param srcPath - The entry's `srcPath` to exclude.
+ * @param entries - All discovered entries.
+ * @returns Entries whose `srcPath` differs from the supplied one.
+ *
+ * @example Building the sibling list for `bundle/`
+ * ```typescript
+ * const siblings = filterSiblings('bundle', allEntries)
+ * ```
+ */
+export declare const filterSiblings: <T extends SiblingFilterEntry>(srcPath: string, entries: T[]) => T[];
+/**
+ * Joins an output base directory with an entry's `srcPath` to produce the
+ * absolute path of the entry's bundled `index.d.ts`.
+ *
+ * @param outputPath - Absolute output directory.
+ * @param srcPath - Entry's `srcPath`. `''` for root.
+ * @returns Absolute path to `<outputPath>/<srcPath>/index.d.ts`.
+ *
+ * @example Computing the d.ts path for a sub-entry
+ * ```typescript
+ * dtsPathFor('/abs/dist/libs/foo', 'models') // => '/abs/dist/libs/foo/models/index.d.ts'
+ * ```
+ */
+export declare const dtsPathFor: (outputPath: string, srcPath: string) => string;
+//# sourceMappingURL=sibling-resolver.d.ts.map

package/bundle/declarations/sibling-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sibling-resolver.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/declarations/sibling-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAIpC;;;;;;;;GAQG;AACH,MAAM,WAAW,YAAY;IAC3B,mFAAmF;IACnF,OAAO,EAAE,MAAM,CAAA;IACf,yDAAyD;IACzD,YAAY,EAAE,MAAM,CAAA;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,sDAAsD;IACtD,WAAW,EAAE,MAAM,CAAA;IACnB,iEAAiE;IACjE,WAAW,EAAE,MAAM,CAAA;IACnB,mDAAmD;IACnD,QAAQ,EAAE,YAAY,EAAE,CAAA;CACzB;AAgCD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,GAAI,cAAc,MAAM,EAAE,UAAU,YAAY,EAAE,KAAG,YAAY,GAAG,SAajG,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,uBAAuB,GAAI,aAAa,MAAM,EAAE,SAAS,YAAY,KAAG,MAgBpF,CAAA;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,8BAA8B,GAAI,OAAO,oBAAoB,KAAG,MAiB5E,CAAA;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,yBAAyB;IACzB,OAAO,EAAE,MAAM,CAAA;CAChB;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,kBAAkB,EAAE,SAAS,MAAM,EAAE,SAAS,CAAC,EAAE,KAAG,CAAC,EACxC,CAAA;AAEtD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,UAAU,GAAI,YAAY,MAAM,EAAE,SAAS,MAAM,KAAG,MACmB,CAAA"}

package/bundle/dedupe/attribute-modules.d.ts

@@ -0,0 +1,178 @@
+import type { ChunkFormat } from '../dependencies/prune/used-exports';
+import ts from 'typescript';
+/**
+ * A first-party module's path under `src/`, without extension and
+ * forward-slashed (e.g. `events/events`, `models`). Doubles as the directory
+ * name the module's hoisted chunk lives under: `_shared/<moduleKey>/`.
+ */
+export type ModuleKey = string;
+/**
+ * Ownership index mapping each unambiguously-owned runtime symbol to the
+ * first-party module that declares it.
+ */
+export interface OwnerIndex {
+    /**
+     * Maps a runtime symbol's base name (rollup `$N` collision suffix stripped)
+     * to its owning module key. Names declared by more than one module are
+     * omitted — an ambiguous name can never be safely attributed.
+     */
+    ownerOf: Map<string, ModuleKey>;
+}
+/**
+ * A single import binding observed at an entry bundle's top level, retaining
+ * enough shape to re-materialize the same edge from a hoisted chunk.
+ */
+export interface ImportBinding {
+    /** Raw module specifier exactly as written in the entry source. */
+    specifier: string;
+    /** Shape of the binding, governing how it is re-emitted into a shared chunk. */
+    kind: 'named' | 'namespace' | 'default' | 'cjs-namespace' | 'cjs-named';
+    /** Exported name on the target module for `named`/`cjs-named` bindings. */
+    imported?: string;
+}
+/**
+ * A removable top-level runtime declaration in an entry bundle, attributed to
+ * its owning first-party module by name.
+ */
+export interface EntryDecl {
+    /** Owning symbol's base name (collision suffix stripped). */
+    base: string;
+    /** Local name exactly as the bundle declares it (may carry a `$N` suffix). */
+    localName: string;
+    /** The owning top-level statement. */
+    statement: ts.Statement;
+    /** Emitted code text (leading comments excluded); the raw chunk-body source. */
+    text: string;
+    /**
+     * Rename-insensitive identity key — `$N` suffixes stripped from identifier
+     * nodes; the raw {@link text} is still the chunk-body source.
+     */
+    fingerprint: string;
+}
+/**
+ * Structural model of one parsed entry bundle.
+ */
+export interface ParsedEntry {
+    /** The parsed source file. */
+    sourceFile: ts.SourceFile;
+    /** Top-level runtime declarations in source order. */
+    decls: EntryDecl[];
+    /** Import/`require` bindings keyed by their local name. */
+    importBindings: Map<string, ImportBinding>;
+    /** Top-level statements that are neither imports, declarations, nor the export surface. */
+    bareStatements: ts.Statement[];
+    /** Every local name a top-level declaration binds. */
+    declNames: Set<string>;
+    /** End offset of the bundle's leading import/`require`/`'use strict'` header — the insertion point for hoisted imports. */
+    headerEnd: number;
+}
+/**
+ * Strips rollup's `$N` collision-rename suffix from a local name, yielding the
+ * canonical source symbol name.
+ *
+ * @param name - A local identifier from an emitted bundle.
+ * @returns The base name with any trailing `$digits` removed.
+ *
+ * @example Undoing a collision rename
+ * ```typescript
+ * baseName('Store$1') // => 'Store'
+ * ```
+ */
+export declare const baseName: (name: string) => string;
+/**
+ * Computes a rename-insensitive identity key for a top-level statement.
+ *
+ * Two copies of the same source that differ only in rollup's per-entry `$N`
+ * collision suffixes compare equal, while genuinely different code never
+ * collides: `$N` is stripped from identifier nodes only, so string literals,
+ * comments, numeric tokens, and discriminating member names stay intact.
+ *
+ * @param statement - The top-level statement to fingerprint.
+ * @param sourceFile - The source file the statement belongs to.
+ * @returns The statement's text with `$N` stripped from every identifier node.
+ *
+ * @example Stripping a dep-namespace local's collision suffix
+ * ```typescript
+ * fingerprintOf(statement, sourceFile) // 'const x = index_cjs_js.getType();' for both `$1` and `$2` copies
+ * ```
+ */
+export declare const fingerprintOf: (statement: ts.Statement, sourceFile: ts.SourceFile) => string;
+/**
+ * Resolves a hoisted module's chunk file name for a format.
+ *
+ * @param format - Output module format.
+ * @returns The per-entry chunk file name (`index.esm.js` / `index.cjs.js`).
+ *
+ * @example Naming the CJS chunk
+ * ```typescript
+ * chunkFileName('cjs') // => 'index.cjs.js'
+ * ```
+ */
+export declare const chunkFileName: (format: ChunkFormat) => string;
+/**
+ * Computes the `_shared/` directory (relative to the output root) that holds a
+ * module's hoisted chunk.
+ *
+ * @param moduleKey - The owning module's key.
+ * @returns The forward-slashed `_shared/<moduleKey>` directory.
+ *
+ * @example Locating a module's shared directory
+ * ```typescript
+ * sharedDirFor('events/events') // => '_shared/events/events'
+ * ```
+ */
+export declare const sharedDirFor: (moduleKey: ModuleKey) => string;
+/**
+ * Parses one entry bundle into the structural model the hoist pass consumes.
+ *
+ * Classifies every top-level statement as an import binding, a removable
+ * runtime declaration, the export surface, or an opaque bare statement. Inline
+ * `export`-modified declarations are treated as part of the export surface
+ * (never removable), so the bundle's published API is never disturbed.
+ *
+ * @param source - Raw entry bundle source text.
+ * @param format - Module format selecting ESM vs CJS import/export shapes.
+ * @returns The parsed entry model.
+ *
+ * @example Modeling an ESM entry bundle
+ * ```typescript
+ * const parsed = parseEntry("import { x } from './_dependencies/a/index.esm.js'\nclass C {}", 'esm')
+ * ```
+ */
+export declare const parseEntry: (source: string, format: ChunkFormat) => ParsedEntry;
+/**
+ * Groups an entry's attributable declarations by their owning module.
+ *
+ * Declarations whose base name is unowned (a dependency or unexported helper
+ * inlined into the bundle) are skipped, leaving them in place.
+ *
+ * @param parsed - A parsed entry bundle.
+ * @param owners - The first-party ownership index.
+ * @returns Map from module key to that module's declarations in source order.
+ *
+ * @example Attributing an entry's declarations
+ * ```typescript
+ * const byModule = attribute(parseEntry(source, 'esm'), owners)
+ * ```
+ */
+export declare const attribute: (parsed: ParsedEntry, owners: OwnerIndex) => Map<ModuleKey, EntryDecl[]>;
+/**
+ * Builds the first-party ownership index by scanning `<srcRoot>/**` for the
+ * runtime symbols each module exports.
+ *
+ * Both exported and private top-level runtime declarations are indexed, so a
+ * module's private helpers hoist alongside the exports that use them. Types-only
+ * modules declare no runtime symbols and contribute nothing. A name declared by
+ * two different modules is ambiguous and dropped from the index, so the pass can
+ * never misattribute it.
+ *
+ * @param srcRoot - Absolute path to the project's `src/` directory.
+ * @returns The ownership index.
+ *
+ * @example Indexing a library's source tree
+ * ```typescript
+ * const owners = indexOwners('/abs/libs/foo/src')
+ * ```
+ */
+export declare const indexOwners: (srcRoot: string) => OwnerIndex;
+//# sourceMappingURL=attribute-modules.d.ts.map

package/bundle/dedupe/attribute-modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attribute-modules.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/dedupe/attribute-modules.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAA;AACrE,OAAO,EAAE,MAAM,YAAY,CAAA;AAM3B;;;;GAIG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,CAAA;AAE9B;;;GAGG;AACH,MAAM,WAAW,UAAU;IACzB;;;;OAIG;IACH,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,SAAS,CAAC,CAAA;CAChC;AAED;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAA;IACjB,gFAAgF;IAChF,IAAI,EAAE,OAAO,GAAG,WAAW,GAAG,SAAS,GAAG,eAAe,GAAG,WAAW,CAAA;IACvE,2EAA2E;IAC3E,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,SAAS;IACxB,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAA;IACZ,8EAA8E;IAC9E,SAAS,EAAE,MAAM,CAAA;IACjB,sCAAsC;IACtC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAA;IACvB,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAA;IACZ;;;OAGG;IACH,WAAW,EAAE,MAAM,CAAA;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,8BAA8B;IAC9B,UAAU,EAAE,EAAE,CAAC,UAAU,CAAA;IACzB,sDAAsD;IACtD,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,2DAA2D;IAC3D,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAC1C,2FAA2F;IAC3F,cAAc,EAAE,EAAE,CAAC,SAAS,EAAE,CAAA;IAC9B,sDAAsD;IACtD,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACtB,2HAA2H;IAC3H,SAAS,EAAE,MAAM,CAAA;CAClB;AAKD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,KAAG,MAAoC,CAAA;AAE5E;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa,GAAI,WAAW,EAAE,CAAC,SAAS,EAAE,YAAY,EAAE,CAAC,UAAU,KAAG,MAelF,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,WAAW,KAAG,MAA4B,CAAA;AAEhF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY,GAAI,WAAW,SAAS,KAAG,MAAgC,CAAA;AA0EpF;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,MAAM,EAAE,QAAQ,WAAW,KAAG,WAoChE,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,SAAS,GAAI,QAAQ,WAAW,EAAE,QAAQ,UAAU,KAAG,GAAG,CAAC,SAAS,EAAE,SAAS,EAAE,CAU7F,CAAA;AAwBD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,MAAM,KAAG,UAqB7C,CAAA"}

package/bundle/dedupe/extract-chunk.d.ts

@@ -0,0 +1,103 @@
+import type { ChunkFormat } from '../dependencies/prune/used-exports';
+import type { EntryDecl, ImportBinding, ModuleKey, OwnerIndex } from './attribute-modules';
+/**
+ * A reference from a module's declarations into another first-party module's
+ * hoisted chunk.
+ */
+export interface CrossRef {
+    /** Local identifier as written in this module's code (may carry a `$N` suffix). */
+    ref: string;
+    /** The referenced symbol's base name — the name the target chunk exports. */
+    base: string;
+    /** Owning module key of the referenced symbol. */
+    moduleKey: ModuleKey;
+}
+/**
+ * A reference from a module's declarations into a dependency import the entry
+ * already carries.
+ */
+export interface DepRef {
+    /** Local identifier as written in this module's code. */
+    ref: string;
+    /** The entry's binding shape for that identifier. */
+    binding: ImportBinding;
+}
+/**
+ * Raw classification of every free identifier a module's declarations reference.
+ */
+export interface ModuleResolution {
+    /** References into other first-party modules. */
+    crossModule: CrossRef[];
+    /** References into dependency imports the entry carries. */
+    depImports: DepRef[];
+    /** References that name an inlined, unattributable top-level entry binding — a hard blocker. */
+    unresolved: string[];
+}
+/** A cross-module import edge resolved to a concrete chunk specifier. */
+export interface CrossImport {
+    /** Local binding name in the emitted chunk. */
+    ref: string;
+    /** Exported name on the target chunk. */
+    exported: string;
+    /** Module specifier reaching the target chunk from this chunk. */
+    specifier: string;
+}
+/** A dependency import edge resolved to a concrete (chunk-relative) specifier. */
+export interface DepImport {
+    /** Local binding name in the emitted chunk. */
+    ref: string;
+    /** Binding shape governing how the import is re-emitted. */
+    kind: ImportBinding['kind'];
+    /** Exported name for `named`/`cjs-named` bindings. */
+    imported?: string;
+    /** Chunk-relative module specifier reaching the dependency. */
+    specifier: string;
+}
+/** Everything needed to render a single module's hoisted chunk. */
+export interface ChunkPlan {
+    /** The module's declarations in canonical source order. */
+    decls: EntryDecl[];
+    /** Resolved cross-module import edges. */
+    crossImports: CrossImport[];
+    /** Resolved dependency import edges. */
+    depImports: DepImport[];
+}
+/**
+ * Classifies every free identifier referenced by a module's declarations,
+ * partitioning them into cross-module edges, dependency edges, and hard
+ * blockers.
+ *
+ * Identifiers the module declares itself are intra-chunk and ignored. A name
+ * that is neither owned, nor a dependency binding, nor a top-level entry
+ * declaration is a runtime global and needs no import. Cross-module references
+ * are always safe to lift because {@link planHoists} only keeps an acyclic
+ * subset, so every dependency chunk is fully evaluated before its dependent.
+ *
+ * @param decls - The module's canonical declarations.
+ * @param owners - First-party ownership index.
+ * @param importBindings - The consuming entry's import bindings.
+ * @param entryDeclNames - Every top-level declaration name in the entry.
+ * @param selfModuleKey - The module being resolved.
+ * @returns The reference resolution.
+ *
+ * @example Resolving a module's references
+ * ```typescript
+ * const resolution = resolveModuleRefs(decls, owners, parsed.importBindings, parsed.declNames, 'events/events')
+ * ```
+ */
+export declare const resolveModuleRefs: (decls: EntryDecl[], owners: OwnerIndex, importBindings: Map<string, ImportBinding>, entryDeclNames: Set<string>, selfModuleKey: ModuleKey) => ModuleResolution;
+/**
+ * Renders a hoisted module chunk: its resolved imports, the union of its
+ * declarations, and an export surface naming each declaration by its base name.
+ *
+ * @param plan - The module's declarations plus resolved import edges.
+ * @param format - Output module format.
+ * @returns The chunk source text.
+ *
+ * @example Rendering an ESM chunk
+ * ```typescript
+ * const source = renderChunk({ decls, crossImports: [], depImports: [] }, 'esm')
+ * ```
+ */
+export declare const renderChunk: (plan: ChunkPlan, format: ChunkFormat) => string;
+//# sourceMappingURL=extract-chunk.d.ts.map

package/bundle/dedupe/extract-chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-chunk.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/dedupe/extract-chunk.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAA;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAA;AAO1F;;;GAGG;AACH,MAAM,WAAW,QAAQ;IACvB,mFAAmF;IACnF,GAAG,EAAE,MAAM,CAAA;IACX,6EAA6E;IAC7E,IAAI,EAAE,MAAM,CAAA;IACZ,kDAAkD;IAClD,SAAS,EAAE,SAAS,CAAA;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB,yDAAyD;IACzD,GAAG,EAAE,MAAM,CAAA;IACX,qDAAqD;IACrD,OAAO,EAAE,aAAa,CAAA;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,iDAAiD;IACjD,WAAW,EAAE,QAAQ,EAAE,CAAA;IACvB,4DAA4D;IAC5D,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,gGAAgG;IAChG,UAAU,EAAE,MAAM,EAAE,CAAA;CACrB;AAED,yEAAyE;AACzE,MAAM,WAAW,WAAW;IAC1B,+CAA+C;IAC/C,GAAG,EAAE,MAAM,CAAA;IACX,yCAAyC;IACzC,QAAQ,EAAE,MAAM,CAAA;IAChB,kEAAkE;IAClE,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,kFAAkF;AAClF,MAAM,WAAW,SAAS;IACxB,+CAA+C;IAC/C,GAAG,EAAE,MAAM,CAAA;IACX,4DAA4D;IAC5D,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;IAC3B,sDAAsD;IACtD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAA;CAClB;AAED,mEAAmE;AACnE,MAAM,WAAW,SAAS;IACxB,2DAA2D;IAC3D,KAAK,EAAE,SAAS,EAAE,CAAA;IAClB,0CAA0C;IAC1C,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,wCAAwC;IACxC,UAAU,EAAE,SAAS,EAAE,CAAA;CACxB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,iBAAiB,GAC5B,OAAO,SAAS,EAAE,EAClB,QAAQ,UAAU,EAClB,gBAAgB,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,EAC1C,gBAAgB,GAAG,CAAC,MAAM,CAAC,EAC3B,eAAe,SAAS,KACvB,gBAuBF,CAAA;AA+CD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,SAAS,EAAE,QAAQ,WAAW,KAAG,MAalE,CAAA"}

package/bundle/dedupe/hoist-shared.d.ts

@@ -0,0 +1,37 @@
+import type { MemoryMonitor } from '../../memory/monitor';
+import type { BuildContext } from '../../models';
+/**
+ * Aggregate result of the shared-first-party hoist pass.
+ */
+export interface HoistReport {
+    /** Number of `_shared/` chunk files written across all formats. */
+    chunksWritten: number;
+    /** Net bytes reclaimed: inlined copies removed minus the shared chunks emitted. */
+    bytesReclaimed: number;
+}
+/**
+ * Lifts first-party modules that are inlined into multiple entry bundles into
+ * shared `_shared/<srcPath>/index.<fmt>.js` chunks and rewrites every consuming
+ * entry to import them.
+ *
+ * Runs as an additive post-emit pass over the already-bundled `esm` and `cjs`
+ * outputs, each processed independently; `iife`/`umd`/`bin` and `.d.ts` outputs
+ * are never read. Per-entry isolated bundling is untouched. Every hoist is
+ * proven safe by {@link planHoists} before it happens — structurally identical
+ * copies, resolvable references, and cycle-free module-initialization — so any module
+ * that cannot be proven safe is left inlined and the output is, worst case,
+ * identical to the input.
+ *
+ * @param context - Resolved build context. `outputPath` locates the bundles and
+ * `projectRoot/src` drives ownership attribution.
+ * @param monitor - Optional memory monitor; a checkpoint is captured after each
+ * format so the pass is observable.
+ * @returns Counts of chunks written and net bytes reclaimed.
+ *
+ * @example Hoisting after the dependency prune
+ * ```typescript
+ * const report = hoistSharedFirstParty(context, monitor)
+ * ```
+ */
+export declare const hoistSharedFirstParty: (context: BuildContext, monitor?: MemoryMonitor) => HoistReport;
+//# sourceMappingURL=hoist-shared.d.ts.map

package/bundle/dedupe/hoist-shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hoist-shared.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/dedupe/hoist-shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAkBhD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,mEAAmE;IACnE,aAAa,EAAE,MAAM,CAAA;IACrB,mFAAmF;IACnF,cAAc,EAAE,MAAM,CAAA;CACvB;AAwGD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,qBAAqB,GAAI,SAAS,YAAY,EAAE,UAAU,aAAa,KAAG,WAWtF,CAAA"}