@hyperfrontend/builder 0.1.0

package/bundle/dedupe/index.esm.js

@@ -0,0 +1,766 @@
+import ts from 'typescript';
+import { createMap } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/map/index.esm.js';
+import { createSet } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/set/index.esm.js';
+import { readFileContent, readDirectory, join, exists, ensureDir, writeFileContent, relativePath } from '../../_dependencies/@hyperfrontend/project-scope/core/index.esm.js';
+import { from } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.esm.js';
+import { logger } from '../../_dependencies/@hyperfrontend/logging/index.esm.js';
+import { entryDirOf } from '../../_shared/bundle/fs/entry-dir/index.esm.js';
+import { parseChunk, getRequireSpecifier } from '../../_shared/bundle/dependencies/prune/ast-utils/index.esm.js';
+
+/** Per-format output chunk file name, mirroring the bundler's entry naming. */
+const CHUNK_FILE = { esm: 'index.esm.js', cjs: 'index.cjs.js' };
+/**
+ * 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'
+ * ```
+ */
+const baseName = (name) => name.replace(/\$\d+$/, '');
+/**
+ * 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
+ * ```
+ */
+const fingerprintOf = (statement, sourceFile) => {
+    const start = statement.getStart(sourceFile);
+    const text = statement.getText(sourceFile);
+    const edits = [];
+    const visit = (node) => {
+        if (ts.isIdentifier(node)) {
+            const base = baseName(node.text);
+            if (base !== node.text)
+                edits.push([node.getStart(sourceFile) - start, node.getEnd() - start, base]);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(statement);
+    let out = text;
+    for (const [s, e, replacement] of edits.sort((a, b) => b[0] - a[0]))
+        out = `${out.slice(0, s)}${replacement}${out.slice(e)}`;
+    return out;
+};
+/**
+ * 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'
+ * ```
+ */
+const chunkFileName = (format) => CHUNK_FILE[format];
+/**
+ * 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'
+ * ```
+ */
+const sharedDirFor = (moduleKey) => `_shared/${moduleKey}`;
+const isExported = (statement) => ts.canHaveModifiers(statement) && (ts.getModifiers(statement) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+const declaredNames = (statement) => {
+    if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement) || ts.isEnumDeclaration(statement)) && statement.name)
+        return [statement.name.text];
+    if (!ts.isVariableStatement(statement))
+        return [];
+    const names = [];
+    for (const decl of statement.declarationList.declarations)
+        if (ts.isIdentifier(decl.name))
+            names.push(decl.name.text);
+    return names;
+};
+const requireSpecifierOf = (initializer) => {
+    if (initializer === undefined)
+        return null;
+    if (ts.isPropertyAccessExpression(initializer))
+        return getRequireSpecifier(initializer.expression);
+    return getRequireSpecifier(initializer);
+};
+const isRequireVarStatement = (statement) => ts.isVariableStatement(statement) &&
+    statement.declarationList.declarations.length > 0 &&
+    statement.declarationList.declarations.every((decl) => requireSpecifierOf(decl.initializer) !== null);
+const collectCjsBindings = (statement, bindings) => {
+    for (const decl of statement.declarationList.declarations) {
+        const specifier = requireSpecifierOf(decl.initializer);
+        if (specifier === null)
+            continue;
+        if (ts.isIdentifier(decl.name)) {
+            // why: `var x = require('s').foo` binds a single named export; the bare `var ns = require('s')` binds the whole namespace.
+            const imported = decl.initializer && ts.isPropertyAccessExpression(decl.initializer) ? decl.initializer.name.text : undefined;
+            bindings.set(decl.name.text, imported ? { specifier, kind: 'cjs-named', imported } : { specifier, kind: 'cjs-namespace' });
+        }
+        else if (ts.isObjectBindingPattern(decl.name)) {
+            for (const element of decl.name.elements)
+                if (ts.isIdentifier(element.name))
+                    bindings.set(element.name.text, { specifier, kind: 'cjs-named', imported: (element.propertyName ?? element.name).getText() });
+        }
+    }
+};
+const collectEsmBindings = (statement, bindings) => {
+    const specifier = statement.moduleSpecifier.text;
+    const clause = statement.importClause;
+    if (!clause)
+        return;
+    if (clause.name)
+        bindings.set(clause.name.text, { specifier, kind: 'default' });
+    if (!clause.namedBindings)
+        return;
+    if (ts.isNamespaceImport(clause.namedBindings)) {
+        bindings.set(clause.namedBindings.name.text, { specifier, kind: 'namespace' });
+        return;
+    }
+    for (const element of clause.namedBindings.elements)
+        bindings.set(element.name.text, { specifier, kind: 'named', imported: (element.propertyName ?? element.name).text });
+};
+const isUseStrict = (statement) => ts.isExpressionStatement(statement) && ts.isStringLiteral(statement.expression) && statement.expression.text === 'use strict';
+const isHeaderStatement = (statement, format) => isUseStrict(statement) || (format === 'esm' ? ts.isImportDeclaration(statement) : isRequireVarStatement(statement));
+const isExportSurface = (statement, format) => {
+    if (format === 'esm')
+        return ts.isExportDeclaration(statement) && !statement.moduleSpecifier;
+    // why: CJS export surface is a chain of `exports.x = y` assignment statements emitted at the bundle tail.
+    if (!ts.isExpressionStatement(statement) || !ts.isBinaryExpression(statement.expression))
+        return false;
+    const { left, operatorToken } = statement.expression;
+    return (operatorToken.kind === ts.SyntaxKind.EqualsToken &&
+        ts.isPropertyAccessExpression(left) &&
+        ts.isIdentifier(left.expression) &&
+        left.expression.text === 'exports');
+};
+/**
+ * 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')
+ * ```
+ */
+const parseEntry = (source, format) => {
+    const sourceFile = parseChunk(source);
+    const decls = [];
+    const importBindings = createMap();
+    const bareStatements = [];
+    const declNames = createSet([]);
+    let headerEnd = 0;
+    let inHeader = true;
+    for (const statement of sourceFile.statements) {
+        if (inHeader && isHeaderStatement(statement, format))
+            headerEnd = statement.getEnd();
+        else
+            inHeader = false;
+        if (format === 'esm' && ts.isImportDeclaration(statement)) {
+            collectEsmBindings(statement, importBindings);
+            continue;
+        }
+        if (format === 'cjs' && isRequireVarStatement(statement)) {
+            collectCjsBindings(statement, importBindings);
+            continue;
+        }
+        if (isUseStrict(statement) || isExportSurface(statement, format))
+            continue;
+        const names = isExported(statement) ? [] : declaredNames(statement);
+        for (const name of names)
+            declNames.add(name);
+        // why: only a single-name, non-exported declaration can be cleanly lifted; multi-declarator and inline-exported statements stay put (and may entangle their module out of the plan).
+        if (names.length !== 1) {
+            bareStatements.push(statement);
+            continue;
+        }
+        decls.push({
+            base: baseName(names[0]),
+            localName: names[0],
+            statement,
+            text: statement.getText(sourceFile),
+            fingerprint: fingerprintOf(statement, sourceFile),
+        });
+    }
+    return { sourceFile, decls, importBindings, bareStatements, declNames, headerEnd };
+};
+/**
+ * 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)
+ * ```
+ */
+const attribute = (parsed, owners) => {
+    const byModule = createMap();
+    for (const decl of parsed.decls) {
+        const moduleKey = owners.ownerOf.get(decl.base);
+        if (moduleKey === undefined)
+            continue;
+        const group = byModule.get(moduleKey) ?? [];
+        group.push(decl);
+        byModule.set(moduleKey, group);
+    }
+    return byModule;
+};
+const toModuleKey = (srcRoot, file) => file
+    .slice(srcRoot.length + 1)
+    .replace(/\.ts$/, '')
+    .split(/[\\/]/)
+    .join('/');
+// why: private top-level helpers (e.g. a reducer's `handlers` map) are inlined alongside the exported symbols that use them; attributing them too lets the whole module hoist instead of bailing on the "unresolved" private reference. Collisions across modules are dropped as ambiguous by indexOwners, preserving safety.
+const ownersFromSource = (source) => {
+    const sourceFile = ts.createSourceFile('module.ts', source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+    const names = [];
+    for (const statement of sourceFile.statements)
+        names.push(...declaredNames(statement));
+    return names;
+};
+const walkTsFiles = (dir, acc) => {
+    for (const entry of readDirectory(dir)) {
+        if (entry.isDirectory)
+            walkTsFiles(entry.path, acc);
+        else if (entry.name.endsWith('.ts') && !entry.name.endsWith('.d.ts') && !entry.name.endsWith('.spec.ts'))
+            acc.push(entry.path);
+    }
+};
+/**
+ * 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')
+ * ```
+ */
+const indexOwners = (srcRoot) => {
+    const files = [];
+    walkTsFiles(srcRoot, files);
+    const firstOwner = createMap();
+    const ambiguous = createSet([]);
+    const ownerOf = createMap();
+    for (const file of files) {
+        const moduleKey = toModuleKey(srcRoot, file);
+        for (const name of ownersFromSource(readFileContent(file))) {
+            if (ambiguous.has(name))
+                continue;
+            const prior = firstOwner.get(name);
+            if (prior !== undefined && prior !== moduleKey) {
+                ambiguous.add(name);
+                ownerOf.delete(name);
+                continue;
+            }
+            firstOwner.set(name, moduleKey);
+            ownerOf.set(name, moduleKey);
+        }
+    }
+    return { ownerOf };
+};
+
+createSet([
+    ts.SyntaxKind.CallExpression,
+    ts.SyntaxKind.NewExpression,
+    ts.SyntaxKind.AwaitExpression,
+    ts.SyntaxKind.YieldExpression,
+    ts.SyntaxKind.TaggedTemplateExpression,
+]);
+/**
+ * Globals whose call observably only mutates-then-returns its (fresh-literal)
+ * argument and is therefore side-effect-free — `freeze`/`seal`/`preventExtensions`
+ * all behave this way on a freshly-built object/array literal.
+ */
+createSet(['Object.freeze', 'Object.seal', 'Object.preventExtensions']);
+/**
+ * Collects the identifier names referenced within a node, excluding identifiers
+ * that sit in a property-name position (`obj.name`, `{ name: … }`, `{ name: x }`
+ * binding keys) since those never refer to a top-level declaration.
+ *
+ * Deliberately over-approximates: a name captured that is not actually a
+ * top-level declaration is harmless, and capturing more only keeps more code.
+ *
+ * @param node - The subtree to scan.
+ * @param sink - Set that receives every referenced identifier name.
+ *
+ * @example Collecting references inside a function body
+ * ```typescript
+ * const refs = createSet<string>([])
+ * collectRefs(functionDeclaration, refs)
+ * ```
+ */
+const collectRefs = (node, sink) => {
+    const visit = (current) => {
+        if (ts.isIdentifier(current)) {
+            const parent = current.parent;
+            if (ts.isPropertyAccessExpression(parent) && parent.name === current)
+                return;
+            if (ts.isPropertyAssignment(parent) && parent.name === current)
+                return;
+            if (ts.isBindingElement(parent) && parent.propertyName === current)
+                return;
+            sink.add(current.text);
+            return;
+        }
+        ts.forEachChild(current, visit);
+    };
+    visit(node);
+};
+
+/**
+ * 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')
+ * ```
+ */
+const resolveModuleRefs = (decls, owners, importBindings, entryDeclNames, selfModuleKey) => {
+    const selfLocals = createSet(decls.map((decl) => decl.localName));
+    const allRefs = createSet([]);
+    for (const decl of decls)
+        collectRefs(decl.statement, allRefs);
+    const crossModule = [];
+    const depImports = [];
+    const unresolved = [];
+    for (const ref of allRefs) {
+        if (selfLocals.has(ref))
+            continue;
+        const base = baseName(ref);
+        const owner = owners.ownerOf.get(base);
+        if (owner !== undefined) {
+            if (owner !== selfModuleKey)
+                crossModule.push({ ref, base, moduleKey: owner });
+            continue;
+        }
+        const binding = importBindings.get(ref);
+        if (binding !== undefined) {
+            depImports.push({ ref, binding });
+            continue;
+        }
+        if (entryDeclNames.has(ref))
+            unresolved.push(ref);
+    }
+    return { crossModule, depImports, unresolved };
+};
+const namedBinding = (local, imported) => (imported === local ? local : `${imported} as ${local}`);
+const cjsBinding$1 = (local, imported) => (imported === local ? local : `${imported}: ${local}`);
+const groupBySpecifier = (items, specifierOf) => {
+    const groups = createMap();
+    for (const item of items) {
+        const group = groups.get(specifierOf(item)) ?? [];
+        group.push(item);
+        groups.set(specifierOf(item), group);
+    }
+    return from(groups.entries()).sort(([a], [b]) => (a < b ? -1 : 1));
+};
+const renderEsmImports = (crossImports, depImports) => {
+    const lines = [];
+    for (const [specifier, group] of groupBySpecifier(crossImports, (c) => c.specifier))
+        lines.push(`import { ${group.map((c) => namedBinding(c.ref, c.exported)).join(', ')} } from '${specifier}';`);
+    for (const dep of depImports.filter((d) => d.kind === 'namespace'))
+        lines.push(`import * as ${dep.ref} from '${dep.specifier}';`);
+    for (const dep of depImports.filter((d) => d.kind === 'default'))
+        lines.push(`import ${dep.ref} from '${dep.specifier}';`);
+    for (const [specifier, group] of groupBySpecifier(depImports.filter((d) => d.kind === 'named'), (d) => d.specifier))
+        lines.push(`import { ${group.map((d) => namedBinding(d.ref, d.imported ?? d.ref)).join(', ')} } from '${specifier}';`);
+    return lines;
+};
+const renderCjsRequires = (crossImports, depImports) => {
+    const lines = [];
+    for (const [specifier, group] of groupBySpecifier(crossImports, (c) => c.specifier))
+        lines.push(`const { ${group.map((c) => cjsBinding$1(c.ref, c.exported)).join(', ')} } = require('${specifier}');`);
+    for (const dep of depImports.filter((d) => d.kind === 'cjs-namespace'))
+        lines.push(`const ${dep.ref} = require('${dep.specifier}');`);
+    for (const [specifier, group] of groupBySpecifier(depImports.filter((d) => d.kind === 'cjs-named'), (d) => d.specifier))
+        lines.push(`const { ${group.map((d) => cjsBinding$1(d.ref, d.imported ?? d.ref)).join(', ')} } = require('${specifier}');`);
+    return lines;
+};
+const renderEsmExports = (decls) => `export { ${decls.map((decl) => (decl.localName === decl.base ? decl.base : `${decl.localName} as ${decl.base}`)).join(', ')} };`;
+const renderCjsExports = (decls) => decls.map((decl) => `exports.${decl.base} = ${decl.localName};`).join('\n');
+/**
+ * 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')
+ * ```
+ */
+const renderChunk = (plan, format) => {
+    const body = plan.decls.map((decl) => decl.text).join('\n');
+    if (format === 'esm') {
+        const imports = renderEsmImports(plan.crossImports, plan.depImports);
+        const blocks = imports.length > 0 ? [imports.join('\n'), body, renderEsmExports(plan.decls)] : [body, renderEsmExports(plan.decls)];
+        return `${blocks.join('\n\n')}\n`;
+    }
+    const requires = renderCjsRequires(plan.crossImports, plan.depImports);
+    const blocks = requires.length > 0
+        ? ["'use strict';", requires.join('\n'), body, renderCjsExports(plan.decls)]
+        : ["'use strict';", body, renderCjsExports(plan.decls)];
+    return `${blocks.join('\n\n')}\n`;
+};
+
+const invertOwners = (owners) => {
+    const byModule = createMap();
+    for (const [base, moduleKey] of owners.ownerOf) {
+        const names = byModule.get(moduleKey) ?? createSet([]);
+        names.add(base);
+        byModule.set(moduleKey, names);
+    }
+    return byModule;
+};
+const collectAppearances = (entries) => {
+    const appearances = createMap();
+    for (const [index, entry] of entries.entries())
+        for (const moduleKey of entry.byModule.keys()) {
+            const list = appearances.get(moduleKey) ?? [];
+            list.push(index);
+            appearances.set(moduleKey, list);
+        }
+    return appearances;
+};
+// why: a bare statement (multi-declarator var, enum IIFE, side-effecting init) that names one of the module's symbols cannot be cleanly split out — its symbol would vanish from the chunk; leave the whole module inlined.
+const isEntangled = (entries, indexes, ownedNames) => indexes.some((index) => entries[index].parsed.bareStatements.some((statement) => {
+    const refs = createSet([]);
+    collectRefs(statement, refs);
+    return from(refs).some((ref) => ownedNames.has(baseName(ref)));
+}));
+const pickCanonical = (entries, moduleKey, indexes) => indexes.reduce((best, index) => (entries[index].byModule.get(moduleKey) ?? []).length > (entries[best].byModule.get(moduleKey) ?? []).length ? index : best);
+const isConsistentCopy = (canonicalFingerprint, order, decls) => {
+    let previous = -1;
+    for (const decl of decls) {
+        const index = order.get(decl.base);
+        // why: a copy that names a declaration absent from the canonical superset, reorders it, or differs structurally (rename-insensitive fingerprint) is not provably the same code.
+        if (index === undefined || index <= previous || canonicalFingerprint.get(decl.base) !== decl.fingerprint)
+            return false;
+        previous = index;
+    }
+    return true;
+};
+const planCandidate = (entries, owners, moduleKey, indexes, ownedNames) => {
+    if (isEntangled(entries, indexes, ownedNames))
+        return null;
+    const canonicalEntryIndex = pickCanonical(entries, moduleKey, indexes);
+    const canonicalDecls = entries[canonicalEntryIndex].byModule.get(moduleKey) ?? [];
+    // why: identity gates on the rename-insensitive fingerprint, but chunk rendering still uses each decl's raw `text` via canonicalDecls.
+    const canonicalFingerprint = createMap();
+    const order = createMap();
+    for (const [index, decl] of canonicalDecls.entries()) {
+        canonicalFingerprint.set(decl.base, decl.fingerprint);
+        order.set(decl.base, index);
+    }
+    for (const index of indexes)
+        if (!isConsistentCopy(canonicalFingerprint, order, entries[index].byModule.get(moduleKey) ?? []))
+            return null;
+    const canonical = entries[canonicalEntryIndex].parsed;
+    const resolution = resolveModuleRefs(canonicalDecls, owners, canonical.importBindings, canonical.declNames, moduleKey);
+    if (resolution.unresolved.length > 0)
+        return null;
+    return { canonicalEntryIndex, decls: canonicalDecls, resolution, consumingEntryIndexes: indexes };
+};
+const closeOverDependencies = (candidates) => {
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const [moduleKey, planned] of candidates)
+            if (planned.resolution.crossModule.some((ref) => !candidates.has(ref.moduleKey))) {
+                candidates.delete(moduleKey);
+                changed = true;
+            }
+    }
+    return candidates;
+};
+// why: shared chunks load topologically, so an acyclic dependency graph guarantees every chunk is fully evaluated before its dependents — no cross-chunk temporal-dead-zone. Modules in (or feeding) a cycle cannot be ordered safely, so they are peeled off and left inlined.
+const keepAcyclic = (candidates) => {
+    const depsOf = createMap();
+    for (const [moduleKey, planned] of candidates)
+        depsOf.set(moduleKey, planned.resolution.crossModule.map((ref) => ref.moduleKey));
+    const pending = createSet(candidates.keys());
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const [moduleKey, deps] of depsOf)
+            if (pending.has(moduleKey) && deps.every((dep) => !pending.has(dep))) {
+                pending.delete(moduleKey);
+                changed = true;
+            }
+    }
+    for (const moduleKey of pending)
+        candidates.delete(moduleKey);
+    return candidates;
+};
+/**
+ * Plans which first-party modules can be hoisted into shared chunks.
+ *
+ * A module qualifies only when it is inlined into at least two entries, is not
+ * entangled with a bare statement, presents structurally identical declarations
+ * (rename-insensitive) in a consistent order across every copy, references
+ * nothing unresolvable, and —
+ * after closure and acyclic peeling — depends only on other hoisted modules
+ * through a cycle-free graph. Anything failing these is left inlined, so the
+ * worst case equals the unmodified output.
+ *
+ * @param entries - Parsed entries with their per-module attribution.
+ * @param owners - First-party ownership index.
+ * @returns Map from module key to its hoist plan.
+ *
+ * @example Planning hoists for a set of entries
+ * ```typescript
+ * const plan = planHoists(entries, owners)
+ * ```
+ */
+const planHoists = (entries, owners) => {
+    const ownedNames = invertOwners(owners);
+    const candidates = createMap();
+    for (const [moduleKey, indexes] of collectAppearances(entries)) {
+        if (indexes.length < 2)
+            continue;
+        const planned = planCandidate(entries, owners, moduleKey, indexes, ownedNames.get(moduleKey) ?? createSet([]));
+        if (planned)
+            candidates.set(moduleKey, planned);
+    }
+    return keepAcyclic(closeOverDependencies(candidates));
+};
+
+const esmBinding = (decl) => (decl.base === decl.localName ? decl.base : `${decl.base} as ${decl.localName}`);
+const cjsBinding = (decl) => (decl.base === decl.localName ? decl.base : `${decl.base}: ${decl.localName}`);
+const renderImport = (hoist, format) => format === 'esm'
+    ? `import { ${hoist.decls.map(esmBinding).join(', ')} } from '${hoist.specifier}';`
+    : `const { ${hoist.decls.map(cjsBinding).join(', ')} } = require('${hoist.specifier}');`;
+const applyEdits = (source, edits) => {
+    let code = source;
+    for (const edit of from(edits).sort((a, b) => b.start - a.start))
+        code = `${code.slice(0, edit.start)}${edit.text}${code.slice(edit.end)}`;
+    // why: splicing whole statements leaves runs of blank lines; collapse them so the trimmed entry stays readable.
+    return code.replace(/\n{3,}/g, '\n\n');
+};
+// why: liveness over-approximates — every identifier node (property names included) counts as a use, so trimming an import can only drop a name nothing references, never one that survives.
+const collectIdentifierNames = (source) => {
+    const names = createSet([]);
+    const visit = (node) => {
+        if (ts.isIdentifier(node))
+            names.add(node.text);
+        ts.forEachChild(node, visit);
+    };
+    visit(parseChunk(source));
+    return names;
+};
+/**
+ * Rewrites an entry bundle to consume hoisted modules from `_shared/` chunks
+ * instead of inlining them.
+ *
+ * Splices every hoisted declaration (and its leading comments) out of the entry
+ * and prepends an import/`require` binding the chunk's base export to the
+ * entry's local name — aliasing when rollup renamed the local (`foo as foo$1`).
+ * Only the hoisted symbols the entry still references after splicing are
+ * re-imported: a private helper used solely by another hoisted export (e.g. a
+ * reducer's `handlers`, used only by the hoisted `rootReducer`) is seen as dead
+ * against the spliced body and omitted from the import, while the chunk it lives
+ * in keeps it. The bundle's export surface is left untouched: surviving spliced
+ * names are now supplied by the inserted imports, so the published API is
+ * byte-for-byte identical to before.
+ *
+ * @param parsed - The parsed entry bundle.
+ * @param hoists - The modules hoisted out of this entry, each with its chunk specifier.
+ * @param format - Output module format.
+ * @returns The rewritten entry source, or the original source when `hoists` is empty.
+ *
+ * @example Rewriting an entry to import a shared module
+ * ```typescript
+ * const rewritten = rewriteEntry(parseEntry(source, 'esm'), [{ decls, specifier: './_shared/state/index.esm.js' }], 'esm')
+ * ```
+ */
+const rewriteEntry = (parsed, hoists, format) => {
+    if (hoists.length === 0)
+        return parsed.sourceFile.text;
+    const deletions = [];
+    for (const hoist of hoists)
+        for (const decl of hoist.decls)
+            deletions.push({ start: decl.statement.getFullStart(), end: decl.statement.getEnd(), text: '' });
+    // why: liveness is measured on the body WITHOUT the hoisted decls (and before re-inserting imports), so a private symbol used only by another hoisted decl (e.g. `handlers`, used only by the hoisted `rootReducer`) is correctly seen as dead and never re-imported.
+    const spliced = applyEdits(parsed.sourceFile.text, deletions);
+    const live = collectIdentifierNames(spliced);
+    const liveHoists = hoists
+        .map((hoist) => ({ ...hoist, decls: hoist.decls.filter((decl) => live.has(decl.localName)) }))
+        .filter((hoist) => hoist.decls.length > 0);
+    if (liveHoists.length === 0)
+        return spliced;
+    const block = liveHoists.map((hoist) => renderImport(hoist, format)).join('\n');
+    const insertion = parsed.headerEnd > 0 ? `\n${block}` : `${block}\n`;
+    return applyEdits(parsed.sourceFile.text, [...deletions, { start: parsed.headerEnd, end: parsed.headerEnd, text: insertion }]);
+};
+
+const log = logger.channel('builder:bundle:dedupe');
+const FORMATS = ['esm', 'cjs'];
+const toSpecifier = (relative) => (relative.startsWith('.') ? relative : `./${relative}`);
+const recomputeSpecifier = (specifier, fromDir, baseDir) => 
+// why: relative `_dependencies`/`_shared` edges move with the chunk; bare and node-builtin specifiers resolve identically from anywhere, so they pass through verbatim.
+specifier.startsWith('.') ? toSpecifier(relativePath(fromDir, join(baseDir, specifier))) : specifier;
+const locateEntries = (context, format) => {
+    const locations = [];
+    for (const entry of context.entryPointDiscovery.entryPoints) {
+        const dir = entryDirOf(entry, context);
+        const file = join(dir, chunkFileName(format));
+        if (exists(file))
+            locations.push({ dir, file });
+    }
+    return locations;
+};
+const chunkFileFor = (context, moduleKey, format) => join(context.outputPath, sharedDirFor(moduleKey), chunkFileName(format));
+const buildChunkPlan = (planned, context, chunkDir, canonicalDir, format) => {
+    const crossImports = planned.resolution.crossModule.map((ref) => ({
+        ref: ref.ref,
+        exported: ref.base,
+        specifier: toSpecifier(relativePath(chunkDir, chunkFileFor(context, ref.moduleKey, format))),
+    }));
+    const depImports = planned.resolution.depImports.map((dep) => ({
+        ref: dep.ref,
+        kind: dep.binding.kind,
+        imported: dep.binding.imported,
+        specifier: recomputeSpecifier(dep.binding.specifier, chunkDir, canonicalDir),
+    }));
+    return { decls: planned.decls, crossImports, depImports };
+};
+const writeChunks = (context, plan, locations, format, report) => {
+    for (const [moduleKey, planned] of plan) {
+        const chunkDir = join(context.outputPath, sharedDirFor(moduleKey));
+        const chunkPlan = buildChunkPlan(planned, context, chunkDir, locations[planned.canonicalEntryIndex].dir, format);
+        const source = renderChunk(chunkPlan, format);
+        ensureDir(chunkDir);
+        writeFileContent(chunkFileFor(context, moduleKey, format), source);
+        report.chunksWritten += 1;
+        report.bytesReclaimed -= Buffer.byteLength(source);
+    }
+};
+const rewriteEntries = (context, plan, entries, locations, format, report) => {
+    for (const [index, entry] of entries.entries()) {
+        const hoists = [];
+        for (const [moduleKey] of plan) {
+            const decls = entry.byModule.get(moduleKey);
+            if (decls === undefined)
+                continue;
+            hoists.push({
+                decls,
+                specifier: toSpecifier(relativePath(locations[index].dir, chunkFileFor(context, moduleKey, format))),
+            });
+            for (const decl of decls)
+                report.bytesReclaimed += Buffer.byteLength(decl.text);
+        }
+        if (hoists.length > 0)
+            writeFileContent(locations[index].file, rewriteEntry(entry.parsed, hoists, format));
+    }
+};
+const processFormat = (context, owners, format, report) => {
+    const locations = locateEntries(context, format);
+    if (locations.length < 2)
+        return;
+    const entries = locations.map((location) => {
+        const parsed = parseEntry(readFileContent(location.file), format);
+        return { parsed, byModule: attribute(parsed, owners) };
+    });
+    const plan = planHoists(entries, owners);
+    if (plan.size === 0)
+        return;
+    writeChunks(context, plan, locations, format, report);
+    rewriteEntries(context, plan, entries, locations, format, report);
+};
+/**
+ * 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)
+ * ```
+ */
+const hoistSharedFirstParty = (context, monitor) => {
+    const report = { chunksWritten: 0, bytesReclaimed: 0 };
+    const srcRoot = join(context.projectRoot, 'src');
+    if (!exists(srcRoot))
+        return report;
+    const owners = indexOwners(srcRoot);
+    for (const format of FORMATS) {
+        processFormat(context, owners, format, report);
+        monitor?.check(`bundle:dedupe:shared-first-party:${format}:end`);
+    }
+    if (report.chunksWritten > 0)
+        log.info(`hoisted ${report.chunksWritten} shared chunk(s), reclaimed ${report.bytesReclaimed} byte(s)`);
+    return report;
+};
+
+export { attribute, baseName, chunkFileName, fingerprintOf, hoistSharedFirstParty, indexOwners, parseEntry, planHoists, renderChunk, resolveModuleRefs, rewriteEntry, sharedDirFor };