@hyperfrontend/builder 0.1.0

package/bundle/index.esm.js

@@ -0,0 +1,3689 @@
+import { from, isArray } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.esm.js';
+import { createError } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.esm.js';
+import { createSet } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/set/index.esm.js';
+import { logger } from '../_dependencies/@hyperfrontend/logging/index.esm.js';
+import { join as join$2, exists, relativePath, removeDirectory, readFileContent, getDirname, readDirectory, ensureDir, writeFileContent, isDirectory, matchGlobPattern } from '../_dependencies/@hyperfrontend/project-scope/core/index.esm.js';
+import { createPromise } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/promise/index.esm.js';
+import { setTimeout, clearInterval, setInterval } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/timers/index.esm.js';
+import { createRequire } from 'node:module';
+import { join as join$1, dirname, isAbsolute, resolve } from 'node:path';
+import { spawn } from 'node:child_process';
+import { rmSync, existsSync, mkdtempSync, readFileSync, cpSync, statSync, unlinkSync, rmdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { stringify, parse } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/json/index.esm.js';
+import { readJsonFileIfExists, exists as exists$1, readJsonFile } from '../_dependencies/@hyperfrontend/project-scope/core/fs/index.esm.js';
+import { join as join$3, normalizeToForwardSlashes as normalizeToForwardSlashes$1 } from '../_dependencies/@hyperfrontend/project-scope/core/path/index.esm.js';
+import { dateNow } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/date/index.esm.js';
+import ts from 'typescript';
+import { createMap } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/map/index.esm.js';
+import { min } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/math/index.esm.js';
+import { keys } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.esm.js';
+import { recover } from '../_shared/memory/recover/index.esm.js';
+import { normalizeToForwardSlashes, join } from '../_shared/bundle/fs/posix-path/index.esm.js';
+import { buildWorkspaceRoutes } from '../_shared/bundle/dependencies/externalize-plugin/index.esm.js';
+import { validateExternalsConfig } from '../_shared/bundle/externals/validate-globals/index.esm.js';
+import { depsRootOf } from '../_shared/bundle/fs/deps-root/index.esm.js';
+import { collectWorkspacePrefixDeps, collectWorkspaceExactSpecifiers } from '../_shared/bundle/dependencies/collect-workspace-deps/index.esm.js';
+import { flattenDeclarationPaths } from '../_shared/bundle/declarations/flatten-paths/index.esm.js';
+import { collectChunkSpecifiers, hasDynamicSpecifier } from '../_shared/bundle/dependencies/prune/specifiers/index.esm.js';
+import { entryDirOf } from '../_shared/bundle/fs/entry-dir/index.esm.js';
+import { isUnderDir } from '../_shared/bundle/fs/under-dir/index.esm.js';
+import { parseChunk, resolveRelativeTarget, getRequireSpecifier, classifyRequireBinding } from '../_shared/bundle/dependencies/prune/ast-utils/index.esm.js';
+import { removeEmptyDirs } from '../_shared/bundle/fs/empty-dirs/index.esm.js';
+import { mergeDemand, classifyNamespaceUse, collectNamespaceUsage } from '../_shared/bundle/dependencies/prune/namespace-usage/index.esm.js';
+import { resolveEntries } from '../_shared/bundle/entries/resolve-entries/index.esm.js';
+
+const log$b = logger.channel('builder:bundle:dependencies:pre-pass');
+const REPORT_DIR_PREFIX$1 = 'hf-builder-prepass-';
+const createReportDir$1 = () => mkdtempSync(join$2(tmpdir(), REPORT_DIR_PREFIX$1));
+const reportPathFor$1 = (reportDir, job, index) => join$2(reportDir, `${index}-${job.dep.replace(/\//g, '__')}-${job.kind}-${job.format}.json`);
+const runOne$1 = (job, reportPath, options) => createPromise((resolve, reject) => {
+    const execPath = options.execPath ?? process.execPath;
+    const argv = [...(options.execArgv ?? []), options.workerPath, stringify({ ...job, reportPath })];
+    const child = spawn(execPath, argv, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let capturedStderr = '';
+    child.stdout?.on('data', (chunk) => {
+        process.stdout.write(chunk);
+    });
+    child.stderr?.on('data', (chunk) => {
+        const text = typeof chunk === 'string' ? chunk : chunk.toString();
+        capturedStderr += text;
+        process.stderr.write(text);
+    });
+    child.on('error', (error) => {
+        reject(createError(`pre-pass worker for ${job.dep} (${job.kind}/${job.format}) failed to spawn: ${error.message}`));
+    });
+    child.on('exit', (code) => {
+        if (code !== 0) {
+            const tail = capturedStderr.trim().split('\n').slice(-10).join('\n');
+            reject(createError(`pre-pass worker for ${job.dep} (${job.kind}/${job.format}) exited with code ${code}\n${tail}`));
+            return;
+        }
+        resolve();
+    });
+});
+const readReport$1 = (reportPath, job) => {
+    if (!existsSync(reportPath)) {
+        throw createError(`pre-pass worker for ${job.dep} (${job.kind}/${job.format}) did not write a report at ${reportPath}`);
+    }
+    const data = parse(readFileSync(reportPath, 'utf8'));
+    return { job, outputSize: data.outputSize, endHeapMB: data.endHeapMB, endRssMB: data.endRssMB, durationMs: data.durationMs };
+};
+const SWC_NODE_REGISTER$1 = '@swc-node/register';
+const swcNodeAvailable$1 = (workspaceRoot) => existsSync(join$2(workspaceRoot, 'node_modules', '@swc-node', 'register', 'index.js'));
+/**
+ * Default worker-path resolution: prefers the built-and-published artifact, falls
+ * back to the workspace dist path, and finally to the in-source TypeScript file
+ * via `@swc-node/register` (bootstrap case where builder is building itself for
+ * the first time and the dist worker doesn't exist yet).
+ *
+ * Looks at, in order:
+ * 1. `<workspaceRoot>/dist/libs/builder/bundle/dependencies/worker/index.cjs.js`
+ * 2. `<workspaceRoot>/node_modules/@hyperfrontend/builder/bundle/dependencies/worker/index.cjs.js`
+ * 3. `<workspaceRoot>/libs/builder/src/bundle/dependencies/worker/index.ts` (with `--require \@swc-node/register`)
+ *
+ * @param workspaceRoot - Absolute workspace root.
+ * @returns Worker invocation descriptor, or `undefined` if no candidate exists.
+ *
+ * @example Locating the worker for an in-workspace consumer
+ * ```typescript
+ * const invocation = resolveDefaultWorkerPath('/abs/repo')
+ * if (!invocation) throw new Error('builder worker artifact not found')
+ * ```
+ */
+const resolveDefaultWorkerPath = (workspaceRoot) => {
+    const distCandidates = [
+        join$2(workspaceRoot, 'dist', 'libs', 'builder', 'bundle', 'dependencies', 'worker', 'index.cjs.js'),
+        join$2(workspaceRoot, 'node_modules', '@hyperfrontend', 'builder', 'bundle', 'dependencies', 'worker', 'index.cjs.js'),
+    ];
+    for (const path of distCandidates) {
+        if (existsSync(path))
+            return { path, execArgv: [] };
+    }
+    const sourcePath = join$2(workspaceRoot, 'libs', 'builder', 'src', 'bundle', 'dependencies', 'worker', 'index.ts');
+    if (existsSync(sourcePath) && swcNodeAvailable$1(workspaceRoot)) {
+        return { path: sourcePath, execArgv: ['--require', SWC_NODE_REGISTER$1] };
+    }
+    return undefined;
+};
+/**
+ * Sequentially runs the supplied pre-pass jobs by forking a fresh Node child
+ * per invocation. Strict sequential execution is mandatory — concurrent
+ * children would simultaneously pressure RAM and OOM the container.
+ *
+ * Each child writes a JSON report to a parent-supplied path; this function
+ * reads the report after the child exits and accumulates per-job statistics.
+ * If any worker exits non-zero or fails to produce a report, the function
+ * throws with the failed job's context.
+ *
+ * The report directory is created in the OS temp dir and removed before
+ * returning, regardless of success or failure.
+ *
+ * @param jobs - Pre-pass jobs to run.
+ * @param options - Worker path + optional memory monitor.
+ * @returns One result per supplied job, in the order the jobs were given.
+ *
+ * @example Pre-passing rollup and one of its plugins
+ * ```typescript
+ * const results = await runPrePass(jobs, { workerPath: '/abs/dist/libs/builder/bundle/dependencies/worker.cjs.js' })
+ * ```
+ */
+const runPrePass = async (jobs, options) => {
+    if (jobs.length === 0)
+        return [];
+    const reportDir = createReportDir$1();
+    const results = [];
+    try {
+        for (const [index, job] of jobs.entries()) {
+            const reportPath = reportPathFor$1(reportDir, job, index);
+            log$b.info(`pre-pass ${index + 1}/${jobs.length}: ${job.dep} (${job.kind}/${job.format})`);
+            options.monitor?.check(`bundle:dependencies:prepass:${index + 1}/${jobs.length}:${job.dep}:${job.kind}:${job.format}:start`);
+            await runOne$1(job, reportPath, options);
+            const result = readReport$1(reportPath, job);
+            log$b.debug(`pre-pass ${index + 1}/${jobs.length} done: ${job.dep} size=${result.outputSize}B heap=${result.endHeapMB.toFixed(1)}MB rss=${result.endRssMB.toFixed(1)}MB t=${result.durationMs}ms`);
+            options.monitor?.check(`bundle:dependencies:prepass:${index + 1}/${jobs.length}:${job.dep}:${job.kind}:${job.format}:end`);
+            results.push(result);
+        }
+        return results;
+    }
+    finally {
+        rmSync(reportDir, { recursive: true, force: true });
+    }
+};
+
+/**
+ * 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'
+ * ```
+ */
+const dtsPathFor = (outputPath, srcPath) => srcPath ? join(outputPath, srcPath, 'index.d.ts') : join(outputPath, 'index.d.ts');
+
+const log$a = logger.channel('builder:bundle:declarations:dts-per-entry');
+const buildSiblingDescriptors = (entries, context, currentSrcPath) => {
+    const descriptors = [];
+    for (const entry of entries) {
+        if (entry.srcPath === currentSrcPath)
+            continue;
+        const indexDtsPath = dtsPathFor(context.outputPath, entry.srcPath);
+        if (!exists(indexDtsPath))
+            continue;
+        descriptors.push({ srcPath: entry.srcPath, indexDtsPath });
+    }
+    return descriptors;
+};
+const buildJobs$1 = (entries, context) => {
+    const jobs = [];
+    const workspacePrefixDeps = collectWorkspacePrefixDeps(context);
+    const workspaceExactSpecifiers = collectWorkspaceExactSpecifiers(context);
+    const workspaceRoutes = buildWorkspaceRoutes(context.workspaceBundledDeps);
+    const depsRoot = depsRootOf(context);
+    for (const entry of entries) {
+        const inputPath = dtsPathFor(context.outputPath, entry.srcPath);
+        if (!exists(inputPath))
+            continue;
+        const siblingEntries = buildSiblingDescriptors(entries, context, entry.srcPath);
+        jobs.push({
+            kind: 'dts',
+            dep: entry.exportPath,
+            inputPath,
+            format: 'esm',
+            outputPath: inputPath,
+            otherDeps: [...context.bundledDeps, ...workspacePrefixDeps],
+            otherWorkspaceSpecifiers: workspaceExactSpecifiers,
+            siblingEntries,
+            selfDtsPath: inputPath,
+            selfSrcPath: entry.srcPath,
+            npmDeps: context.bundledDeps,
+            workspaceRoutes,
+            depsRoot,
+        });
+    }
+    return jobs;
+};
+/**
+ * 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).
+ *
+ * @param context - Resolved build context.
+ * @param monitor - Optional memory monitor invoked between jobs.
+ * @throws {Error} When the worker artifact cannot be located, or when any per-entry job fails.
+ *
+ * @example Inlining bundled-dep types into every entry's .d.ts after tsc emission
+ * ```typescript
+ * await runDtsPerEntry(context)
+ * ```
+ */
+const runDtsPerEntry = async (context, monitor) => {
+    if (context.bundledDeps.length === 0 && context.workspaceBundledDeps.length === 0)
+        return;
+    const invocation = resolveDefaultWorkerPath(context.workspaceRoot);
+    if (!invocation) {
+        throw createError('bundleAllDeps is enabled but the pre-pass worker artifact was not found for the per-entry d.ts pass.');
+    }
+    const jobs = buildJobs$1(context.entryPointDiscovery.entryPoints, context);
+    if (jobs.length === 0) {
+        log$a.debug('per-entry d.ts pass: no entries with tsc-emitted .d.ts files');
+        return;
+    }
+    log$a.info(`per-entry d.ts pass: ${jobs.length} entries`);
+    monitor?.check('bundle:declarations:dts-perentry:start');
+    await runPrePass(jobs, { workerPath: invocation.path, execArgv: invocation.execArgv, monitor });
+    monitor?.check('bundle:declarations:dts-perentry:end');
+};
+
+const ROOTS = (projectRoot, workspaceRoot) => [projectRoot, workspaceRoot];
+const findPackageJsonByWalkingUp = (entryPath, dep) => {
+    const segments = entryPath.split('/');
+    for (let i = segments.length - 1; i > 0; i--) {
+        const prefix = segments.slice(0, i).join('/');
+        const candidate = `${prefix}/package.json`;
+        if (!exists$1(candidate))
+            continue;
+        try {
+            const meta = readJsonFileIfExists(candidate);
+            if (meta?.name === dep)
+                return candidate;
+        }
+        catch {
+            // fall through
+        }
+    }
+    return undefined;
+};
+const findPackageJsonViaRequire = (dep, fromRoots) => {
+    for (const root of fromRoots) {
+        try {
+            const anchor = join$3(root, 'package.json');
+            if (!exists$1(anchor))
+                continue;
+            const req = createRequire(anchor);
+            const direct = `${dep}/package.json`;
+            try {
+                const path = req.resolve(direct);
+                if (exists$1(path))
+                    return path;
+            }
+            catch {
+                // package may restrict ./package.json via exports — fall through to entry-anchored walk
+            }
+            try {
+                const entryPath = req.resolve(dep);
+                const found = findPackageJsonByWalkingUp(entryPath, dep);
+                if (found)
+                    return found;
+            }
+            catch {
+                // entry resolution may also fail (e.g., type-only package); try the next root
+            }
+        }
+        catch {
+            // try next root
+        }
+    }
+    return undefined;
+};
+const ensureJsEntry = (pkg) => pkg.module ?? pkg.main;
+const ensureDtsEntry = (pkg) => pkg.types ?? pkg.typings;
+const absolutize = (relativeTo, rel) => {
+    if (isAbsolute(rel))
+        return normalizeToForwardSlashes$1(rel);
+    return normalizeToForwardSlashes$1(resolve(relativeTo, rel));
+};
+/**
+ * Resolves the absolute path to a bundled dep's entry file (JS or `.d.ts`) for a
+ * pre-pass invocation.
+ *
+ * For JS jobs the resolution prefers the dep's `module` field (ESM) over `main`
+ * (CJS). For dts jobs it prefers `types` over `typings`. Lookup walks the project
+ * root first, then the workspace root, using `createRequire` so node's standard
+ * resolution semantics apply (including support for hoisted `node_modules`).
+ *
+ * @param options - Dep name, root paths, and kind.
+ * @returns Absolute path to the dep's entry file.
+ * @throws {Error} When the dep's `package.json` cannot be located or it lacks the
+ * required entry field.
+ *
+ * @example Resolving the runtime entry for `rollup`
+ * ```typescript
+ * const entry = resolveDepEntry({ dep: 'rollup', projectRoot, workspaceRoot, kind: 'js' })
+ * ```
+ */
+const resolveDepEntry = (options) => {
+    const { dep, projectRoot, workspaceRoot, kind } = options;
+    const pkgPath = findPackageJsonViaRequire(dep, ROOTS(projectRoot, workspaceRoot));
+    if (!pkgPath)
+        throw createError(`pre-pass: cannot locate package.json for dep "${dep}"`);
+    const pkg = readJsonFileIfExists(pkgPath);
+    if (!pkg)
+        throw createError(`pre-pass: package.json for dep "${dep}" could not be read at ${pkgPath}`);
+    const relative = kind === 'js' ? ensureJsEntry(pkg) : ensureDtsEntry(pkg);
+    if (!relative)
+        throw createError(`pre-pass: dep "${dep}" has no ${kind === 'js' ? 'main/module' : 'types/typings'} entry`);
+    return absolutize(dirname(pkgPath), relative);
+};
+
+const log$9 = logger.channel('builder:bundle:declarations:dts-pre-pass');
+const workspaceDtsOutputFile = (entry) => entry.subPath ? `${entry.specifier}/index.d.ts` : `${entry.packageName}/index.d.ts`;
+const filterRouteEntries$1 = (entry, all) => all.filter((other) => (entry.policy === 'sub-path' ? other.specifier !== entry.specifier : other.packageName !== entry.packageName));
+const buildJobs = (deps, context) => {
+    const depsRoot = depsRootOf(context);
+    const jobs = [];
+    const workspacePrefixDeps = collectWorkspacePrefixDeps(context);
+    const workspaceExactSpecifiers = collectWorkspaceExactSpecifiers(context);
+    const workspaceRoutes = buildWorkspaceRoutes(context.workspaceBundledDeps);
+    for (const dep of deps) {
+        let inputPath;
+        try {
+            inputPath = resolveDepEntry({ dep, projectRoot: context.projectRoot, workspaceRoot: context.workspaceRoot, kind: 'dts' });
+        }
+        catch (error) {
+            log$9.warn(`skipping d.ts pre-pass for ${dep}: ${error instanceof Error ? error.message : String(error)}`);
+            continue;
+        }
+        const otherNpmDeps = deps.filter((d) => d !== dep);
+        jobs.push({
+            kind: 'dts',
+            dep,
+            inputPath,
+            format: 'esm',
+            outputPath: join$2(depsRoot, dep, 'index.d.ts'),
+            otherDeps: [...otherNpmDeps, ...workspacePrefixDeps],
+            otherWorkspaceSpecifiers: workspaceExactSpecifiers,
+            npmDeps: otherNpmDeps,
+            workspaceRoutes,
+            depsRoot,
+        });
+    }
+    return jobs;
+};
+const buildWorkspaceJobs = (context, npmDeps) => {
+    if (context.workspaceBundledDeps.length === 0)
+        return [];
+    const depsRoot = depsRootOf(context);
+    const wholeSurface = collectWorkspacePrefixDeps(context);
+    const subPathSpecifiers = collectWorkspaceExactSpecifiers(context);
+    const jobs = [];
+    for (const entry of context.workspaceBundledDeps) {
+        const otherWorkspacePackages = wholeSurface.filter((name) => name !== entry.packageName || entry.policy === 'sub-path');
+        const otherSubPathSpecifiers = subPathSpecifiers.filter((spec) => spec !== entry.specifier);
+        const workspaceRoutes = buildWorkspaceRoutes(filterRouteEntries$1(entry, context.workspaceBundledDeps));
+        jobs.push({
+            kind: 'workspace-dts',
+            dep: entry.specifier,
+            inputPath: entry.inputPath,
+            format: 'esm',
+            outputPath: join$2(depsRoot, workspaceDtsOutputFile(entry)),
+            otherDeps: [...npmDeps, ...otherWorkspacePackages],
+            otherWorkspaceSpecifiers: otherSubPathSpecifiers,
+            tsConfigPath: entry.tsConfigPath,
+            workspaceRoot: context.workspaceRoot,
+            npmDeps,
+            workspaceRoutes,
+            depsRoot,
+        });
+    }
+    return jobs;
+};
+/**
+ * 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/`.
+ *
+ * @param context - Resolved build context.
+ * @param monitor - Optional memory monitor invoked between jobs.
+ * @throws {Error} When the worker artifact cannot be located, or when any d.ts job fails.
+ *
+ * @example Producing _dependencies/<dep>/index.d.ts for a self-contained build
+ * ```typescript
+ * await runDtsPrePass(context)
+ * ```
+ */
+const runDtsPrePass = async (context, monitor) => {
+    if (context.bundledDeps.length === 0 && context.workspaceBundledDeps.length === 0)
+        return;
+    const invocation = resolveDefaultWorkerPath(context.workspaceRoot);
+    if (!invocation) {
+        throw createError('bundleAllDeps is enabled but the pre-pass worker artifact was not found for the d.ts pre-pass.');
+    }
+    const npmJobs = buildJobs(context.bundledDeps, context);
+    const workspaceJobs = buildWorkspaceJobs(context, context.bundledDeps);
+    const jobs = [...npmJobs, ...workspaceJobs];
+    if (jobs.length === 0) {
+        log$9.debug('d.ts pre-pass: no eligible deps (all skipped due to missing types)');
+        return;
+    }
+    log$9.info(`d.ts pre-pass: ${npmJobs.length} npm + ${workspaceJobs.length} workspace = ${jobs.length} job(s)`);
+    monitor?.check('bundle:declarations:dts-prepass:start');
+    await runPrePass(jobs, { workerPath: invocation.path, execArgv: invocation.execArgv, monitor });
+    monitor?.check('bundle:declarations:dts-prepass:end');
+};
+
+const log$8 = logger.channel('builder:bundle:declarations');
+const HEARTBEAT_INTERVAL_MS = 5000;
+const BYTES_PER_MB = 1024 * 1024;
+const formatMB = (bytes) => (bytes / BYTES_PER_MB).toFixed(1);
+const startHeartbeat = (label, startedAt) => setInterval(() => {
+    const usage = process.memoryUsage();
+    const elapsedSec = ((dateNow() - startedAt) / 1000).toFixed(1);
+    log$8.info(`${label} still running: elapsed=${elapsedSec}s parent heap=${formatMB(usage.heapUsed)}MB rss=${formatMB(usage.rss)}MB`);
+}, HEARTBEAT_INTERVAL_MS);
+const runTsc = (tscPath, args, cwd) => createPromise((resolve, reject) => {
+    const startedAt = dateNow();
+    const child = spawn(tscPath, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
+    log$8.info(`tsc spawned: pid=${child.pid ?? 'unknown'}`);
+    log$8.debug(`tsc args: ${args.join(' ')}`);
+    const heartbeat = startHeartbeat('tsc', startedAt);
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (chunk) => {
+        const text = chunk.toString();
+        stdout += text;
+        log$8.debug(text.trimEnd());
+    });
+    child.stderr.on('data', (chunk) => {
+        const text = chunk.toString();
+        stderr += text;
+        log$8.warn(text.trimEnd());
+    });
+    child.on('error', (error) => {
+        clearInterval(heartbeat);
+        log$8.error(`tsc spawn error: ${error.message}`);
+        reject(error);
+    });
+    child.on('close', (code) => {
+        clearInterval(heartbeat);
+        const durationMs = dateNow() - startedAt;
+        if (code !== 0) {
+            log$8.error(`tsc failed with exit code ${code} after ${durationMs}ms`);
+            reject(createError(`tsc failed with exit code ${code}`));
+            return;
+        }
+        log$8.info(`tsc exited 0 in ${durationMs}ms`);
+        resolve({ success: true, stdout, stderr });
+    });
+});
+/**
+ * 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.
+ *
+ * @param context - Resolved build context. Provides project root, output path, tsconfig path,
+ * workspace root, and entry point discovery for the flatten step.
+ * @returns Promise resolving with tsc's exit status, captured stdout, and captured stderr.
+ * @throws {Error} When tsc exits with a non-zero status or fails to spawn.
+ *
+ * @example Generating declarations as part of a custom build
+ * ```typescript
+ * const result = await generateDeclarations(context)
+ * console.log(result.stdout)
+ * ```
+ */
+const generateDeclarations = async (context) => {
+    log$8.info('generating typescript declarations');
+    const usage = process.memoryUsage();
+    log$8.info(`pre-tsc memory: parent heap=${formatMB(usage.heapUsed)}MB rss=${formatMB(usage.rss)}MB`);
+    const tscPath = join$3(context.workspaceRoot, 'node_modules', '.bin', 'tsc');
+    const args = [
+        '--project',
+        context.tsConfigPath,
+        '--noEmit',
+        'false',
+        '--emitDeclarationOnly',
+        '--declaration',
+        '--declarationMap',
+        '--outDir',
+        context.outputPath,
+    ];
+    const result = await runTsc(tscPath, args, context.projectRoot);
+    log$8.info('flattening declaration paths');
+    const flattenStart = dateNow();
+    flattenDeclarationPaths(context);
+    log$8.info(`flatten complete in ${dateNow() - flattenStart}ms`);
+    return result;
+};
+
+const log$7 = logger.channel('builder:bundle:declarations:prune-orphans');
+const ORPHAN_DTS_RE = /\.d\.ts$|\.d\.ts\.map$/;
+const INDEX_DTS_NAME = 'index.d.ts';
+/**
+ * Resolves a relative specifier found in a `.d.ts` to the absolute `.d.ts` file
+ * it points at, or `null` when it resolves to nothing on disk or into
+ * `_dependencies/`.
+ *
+ * Declaration specifiers are extensionless (`./create-logger`, `./shared/consts`)
+ * or directory imports (`./shared` → `shared/index.d.ts`); the canonical
+ * `_dependencies` routing uses an explicit runtime extension (`.../index.js`),
+ * which is rewritten to its declaration sibling. Targets under `depsRoot` are
+ * never edges for this pass — bundled-dep declarations are managed by the
+ * dependency Type Prune, and this pass must never touch them.
+ *
+ * @param dir - Absolute directory of the referencing `.d.ts`.
+ * @param spec - Relative specifier text (already known to start with `.`).
+ * @param depsRoot - Absolute path to the `_dependencies/` directory.
+ * @returns Absolute `.d.ts` path of the referenced sibling, or `null`.
+ */
+const toDtsTarget$1 = (dir, spec, depsRoot) => {
+    const abs = join$2(dir, spec);
+    // why: a `.js` specifier is the bundled-dep routing shape; map it onto its declaration sibling.
+    const candidates = spec.endsWith('.js') ? [`${abs.slice(0, -3)}.d.ts`] : [`${abs}.d.ts`, join$2(abs, INDEX_DTS_NAME)];
+    for (const candidate of candidates) {
+        if (isUnderDir(candidate, depsRoot))
+            return null;
+        if (exists(candidate))
+            return candidate;
+    }
+    return null;
+};
+/**
+ * Computes the set of `.d.ts` files reachable from the entry-point `index.d.ts`
+ * roots by transitively following their relative specifiers.
+ *
+ * Breadth-first: each visited file's text is read, scanned once, then released
+ * before the next, so only one declaration source is resident at a time and the
+ * memory profile stays flat. Edges into `_dependencies/` and to non-existent
+ * targets are dropped. The specifier scan over-approximates (a spurious match
+ * over-keeps harmless bytes) so it never under-keeps a referenced sibling.
+ *
+ * If any reached `.d.ts` contains a dynamic (non-literal) `import(`/`require(`,
+ * the graph cannot be fully resolved, so the function returns `null` — the
+ * safe sentinel that makes the caller keep every declaration.
+ *
+ * @param roots - Absolute paths to the entry-point `index.d.ts` roots.
+ * @param depsRoot - Absolute path to the `_dependencies/` directory.
+ * @returns The set of reachable absolute `.d.ts` paths, or `null` on a dynamic
+ * specifier bail.
+ */
+const computeReachableDeclarations = (roots, depsRoot) => {
+    const reachable = createSet([]);
+    const queue = [];
+    for (const root of roots) {
+        if (exists(root) && !reachable.has(root)) {
+            reachable.add(root);
+            queue.push(root);
+        }
+    }
+    let head = 0;
+    while (head < queue.length) {
+        const file = queue[head];
+        head += 1;
+        // why: every queued path was `exists`-checked before enqueue (roots and `toDtsTarget` targets), so a direct read is safe.
+        const source = readFileContent(file);
+        if (hasDynamicSpecifier(source)) {
+            log$7.warn(`dynamic import/require in ${file}; keeping all orphan declarations for safety`);
+            return null;
+        }
+        const dir = getDirname(file);
+        for (const spec of collectChunkSpecifiers(source)) {
+            const target = toDtsTarget$1(dir, spec, depsRoot);
+            if (target !== null && !reachable.has(target)) {
+                reachable.add(target);
+                queue.push(target);
+            }
+        }
+    }
+    return reachable;
+};
+/**
+ * Collects every `.d.ts` / `.d.ts.map` file under `root`, recursing the whole
+ * package tree but skipping the `_dependencies/` subtree (managed by the
+ * dependency Type Prune, never touched here).
+ *
+ * @param root - Absolute path to the package output root.
+ * @param depsRoot - Absolute path to the `_dependencies/` directory.
+ * @returns Absolute paths of all declaration files outside `_dependencies/`.
+ */
+const collectDeclarationFiles = (root, depsRoot) => {
+    const files = [];
+    if (!exists(root))
+        return files;
+    const visit = (dir) => {
+        for (const entry of readDirectory(dir)) {
+            if (entry.isDirectory) {
+                if (isUnderDir(entry.path, depsRoot))
+                    continue;
+                visit(entry.path);
+            }
+            else if (entry.isFile && ORPHAN_DTS_RE.test(entry.name)) {
+                files.push(entry.path);
+            }
+        }
+    };
+    visit(root);
+    return files;
+};
+/**
+ * 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)
+ * ```
+ */
+const pruneOrphanDeclarations = (context) => {
+    const depsRoot = depsRootOf(context);
+    const roots = [];
+    for (const entry of context.entryPointDiscovery.entryPoints) {
+        const dir = entryDirOf(entry, context);
+        if (isUnderDir(dir, depsRoot))
+            continue;
+        roots.push(join$2(dir, INDEX_DTS_NAME));
+    }
+    const reachable = computeReachableDeclarations(roots, depsRoot);
+    if (reachable === null)
+        return 0;
+    let total = 0;
+    for (const file of collectDeclarationFiles(context.outputPath, depsRoot)) {
+        // why: a `.d.ts.map` shares the liveness of its `.d.ts` sibling, keyed by stripping the trailing `.map`.
+        const dtsKey = file.endsWith('.d.ts.map') ? file.slice(0, -4) : file;
+        if (reachable.has(dtsKey))
+            continue;
+        unlinkSync(file);
+        total += 1;
+    }
+    if (total > 0)
+        log$7.info(`pruned ${total} orphan declaration file(s)`);
+    return total;
+};
+
+/** 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$1 = (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$1(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$1(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 };
+};
+
+const EVAL_SIDE_EFFECT_KINDS = 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.
+ */
+const PURE_GLOBAL_CALLEES = createSet(['Object.freeze', 'Object.seal', 'Object.preventExtensions']);
+// context: dotted global-rooted name for a call target, with a leading `globalThis.` stripped and each top-level binding resolved through `resolution`. Null when the base is a local binding that does not resolve to a global (a shadow) or is not a plain identifier/property chain (a call, element access, …).
+const canonicalCallee = (expr, resolution) => {
+    if (ts.isIdentifier(expr)) {
+        const mapped = resolution.canonical.get(expr.text);
+        if (mapped !== undefined)
+            return mapped;
+        // why: a top-level binding that did not resolve to a global alias shadows that global; treat as opaque so e.g. `const Object = {}` disables bare `Object.freeze`.
+        return resolution.bindings.has(expr.text) ? null : expr.text;
+    }
+    if (ts.isPropertyAccessExpression(expr)) {
+        const base = canonicalCallee(expr.expression, resolution);
+        if (base === null)
+            return null;
+        const dotted = `${base}.${expr.name.text}`;
+        return dotted.startsWith('globalThis.') ? dotted.slice('globalThis.'.length) : dotted;
+    }
+    return null;
+};
+/**
+ * Maps each top-level binding to its canonical global-rooted callee form, in
+ * source order so a later alias resolves through an earlier one. Both `const`
+ * and `var` are resolved; bundled dep chunks never reassign these interop
+ * bindings. A call/literal initializer is opaque and only contributes a
+ * shadowing entry in `bindings`.
+ *
+ * @param sourceFile - The parsed chunk whose top-level bindings are resolved.
+ * @returns The binding resolution: every top-level name plus the global-rooted
+ * canonical form of each identifier/property-chain alias.
+ *
+ * @example Resolving an alias-of-global freeze
+ * ```typescript
+ * const { canonical } = collectBindingCanonical(parseChunk('const _O = globalThis.Object;\nconst freeze = _O.freeze;'))
+ * canonical.get('freeze') // => 'Object.freeze'
+ * ```
+ */
+const collectBindingCanonical = (sourceFile) => {
+    const resolution = { bindings: createSet([]), canonical: createMap() };
+    for (const statement of sourceFile.statements) {
+        if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name)
+            resolution.bindings.add(statement.name.text);
+        if (!ts.isVariableStatement(statement))
+            continue;
+        for (const decl of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(decl.name))
+                continue;
+            resolution.bindings.add(decl.name.text);
+            // why: only an identifier/property-access initializer can alias a global; resolve it through the bindings collected so far (leftmost identifier only).
+            if (decl.initializer && (ts.isIdentifier(decl.initializer) || ts.isPropertyAccessExpression(decl.initializer))) {
+                const resolved = canonicalCallee(decl.initializer, resolution);
+                if (resolved !== null)
+                    resolution.canonical.set(decl.name.text, resolved);
+            }
+        }
+    }
+    return resolution;
+};
+/**
+ * Reports whether a call is a recognized pure callee
+ * (`Object.freeze`/`seal`/`preventExtensions`, however aliased) over a fresh
+ * object/array literal. The argument must be a same-expression literal —
+ * freezing a shared binding mutates it observably, so an identifier argument is
+ * rejected. This checks only the callee and argument shape, not the purity of
+ * the argument's own subexpressions.
+ *
+ * @param call - The call expression to classify.
+ * @param resolution - The chunk's binding resolution, used to canonicalize the callee.
+ * @returns `true` when the call is an observably pure freeze of a fresh literal.
+ *
+ * @example Recognizing an aliased freeze of a fresh literal
+ * ```typescript
+ * const sourceFile = parseChunk('const _O = globalThis.Object;\nconst X = _O.freeze({ a: 1 });')
+ * // for the `_O.freeze({ a: 1 })` call node
+ * isPureFreezeCall(call, collectBindingCanonical(sourceFile)) // => true
+ * ```
+ */
+const isPureFreezeCall = (call, resolution) => {
+    const callee = canonicalCallee(call.expression, resolution);
+    if (callee === null || !PURE_GLOBAL_CALLEES.has(callee))
+        return false;
+    if (call.arguments.length < 1)
+        return false;
+    const first = call.arguments[0];
+    return ts.isObjectLiteralExpression(first) || ts.isArrayLiteralExpression(first);
+};
+/**
+ * Reports whether a call is `<global-rooted chain>.bind(…)`.
+ * `Function.prototype.bind` only builds and returns a new bound function — no
+ * observable side effect. The receiver must canonicalize to a global so an
+ * arbitrary user object's `.bind` — potentially a redefined, side-effecting
+ * method — is never assumed pure. As with {@link isPureFreezeCall}, this checks
+ * only the call shape, not the purity of the argument's own subexpressions.
+ *
+ * @param call - The call expression to classify.
+ * @param resolution - The chunk's binding resolution, used to canonicalize the receiver.
+ * @returns `true` when the call binds a method off a global-rooted receiver chain.
+ *
+ * @example Recognizing a bind of a global-rooted receiver
+ * ```typescript
+ * const sourceFile = parseChunk('const _P = globalThis.Promise;\nconst X = _P.resolve.bind(_P);')
+ * // for the `_P.resolve.bind(_P)` call node
+ * isPureBindCall(call, collectBindingCanonical(sourceFile)) // => true
+ * ```
+ */
+const isPureBindCall = (call, resolution) => {
+    const callee = call.expression;
+    if (!ts.isPropertyAccessExpression(callee) || callee.name.text !== 'bind')
+        return false;
+    return canonicalCallee(callee.expression, resolution) !== null;
+};
+
+const PURE_ANNOTATION = /[@#]__PURE__/;
+
+const isAnnotatedPure = (node) => PURE_ANNOTATION.test(node.getSourceFile().text.slice(node.getFullStart(), node.getStart()));
+
+const containsEvalSideEffect = (node, resolution) => {
+    let found = false;
+    const visit = (current) => {
+        if (found || ts.isFunctionLike(current))
+            return;
+        if (ts.isCallExpression(current) || ts.isNewExpression(current)) {
+            if ((ts.isCallExpression(current) && (isPureFreezeCall(current, resolution) || isPureBindCall(current, resolution))) ||
+                isAnnotatedPure(current)) {
+                ts.forEachChild(current, visit);
+                return;
+            }
+            found = true;
+            return;
+        }
+        if (EVAL_SIDE_EFFECT_KINDS.has(current.kind)) {
+            found = true;
+            return;
+        }
+        ts.forEachChild(current, visit);
+    };
+    visit(node);
+    return found;
+};
+const isSideEffectFreeInitializer = (initializer, resolution) => initializer === undefined || !containsEvalSideEffect(initializer, resolution);
+/**
+ * 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);
+};
+const hasExportModifier = (node) => ts.canHaveModifiers(node) && (ts.getModifiers(node) ?? []).some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+const isRequireInitializer = (init) => getRequireSpecifier(init) !== null || (ts.isPropertyAccessExpression(init) && getRequireSpecifier(init.expression) !== null);
+const isRequireVarStatement = (statement) => ts.isVariableStatement(statement) &&
+    statement.declarationList.declarations.some((decl) => decl.initializer !== undefined && isRequireInitializer(decl.initializer));
+/**
+ * Returns the local binding names introduced by a CJS `require` variable
+ * statement, across identifier and object-destructure bindings.
+ *
+ * @param statement - A variable statement known to bind a `require` call.
+ * @returns The local names it introduces.
+ *
+ * @example Bindings of a destructured require
+ * ```typescript
+ * // for `var { a, b } = require('./x.cjs.js')`
+ * requireBindingLocals(statement) // => ['a', 'b']
+ * ```
+ */
+const requireBindingLocals = (statement) => {
+    const locals = [];
+    if (!ts.isVariableStatement(statement))
+        return locals;
+    for (const decl of statement.declarationList.declarations) {
+        if (ts.isIdentifier(decl.name))
+            locals.push(decl.name.text);
+        else if (ts.isObjectBindingPattern(decl.name))
+            for (const element of decl.name.elements)
+                if (ts.isIdentifier(element.name))
+                    locals.push(element.name.text);
+    }
+    return locals;
+};
+const tryDecl = (statement, resolution) => {
+    if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name) {
+        return { statement, names: [statement.name.text], sideEffectFree: true };
+    }
+    if (!ts.isVariableStatement(statement))
+        return null;
+    const names = [];
+    let sideEffectFree = true;
+    for (const decl of statement.declarationList.declarations) {
+        // why: a destructured top-level binding is not a simple named export and its initializer is typically a call — never treat it as a removable declaration.
+        if (!ts.isIdentifier(decl.name))
+            return null;
+        names.push(decl.name.text);
+        if (!isSideEffectFreeInitializer(decl.initializer, resolution))
+            sideEffectFree = false;
+    }
+    return { statement, names, sideEffectFree };
+};
+const collectEsmExports = (statement, entries, surface) => {
+    if (ts.isExportDeclaration(statement) &&
+        !statement.moduleSpecifier &&
+        statement.exportClause &&
+        ts.isNamedExports(statement.exportClause)) {
+        surface.add(statement);
+        for (const element of statement.exportClause.elements)
+            entries.push({ exported: element.name.text, local: (element.propertyName ?? element.name).text, statement, kind: 'esm-list' });
+        return;
+    }
+    if (!hasExportModifier(statement))
+        return;
+    if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name) {
+        entries.push({ exported: statement.name.text, local: statement.name.text, statement, kind: 'esm-inline' });
+    }
+    else if (ts.isVariableStatement(statement)) {
+        for (const decl of statement.declarationList.declarations)
+            if (ts.isIdentifier(decl.name))
+                entries.push({ exported: decl.name.text, local: decl.name.text, statement, kind: 'esm-inline' });
+    }
+};
+const collectCjsExports = (statement, entries, surface) => {
+    if (!ts.isExpressionStatement(statement) || !ts.isBinaryExpression(statement.expression))
+        return;
+    const { left, operatorToken, right } = statement.expression;
+    if (operatorToken.kind !== ts.SyntaxKind.EqualsToken)
+        return;
+    if (ts.isPropertyAccessExpression(left) &&
+        ts.isIdentifier(left.expression) &&
+        left.expression.text === 'exports' &&
+        ts.isIdentifier(left.name) &&
+        ts.isIdentifier(right)) {
+        surface.add(statement);
+        entries.push({ exported: left.name.text, local: right.text, statement, kind: 'cjs-assign' });
+    }
+};
+/**
+ * Builds the structural model of a chunk: its removable declarations, import
+ * sites, and export surface.
+ *
+ * @param sourceFile - The parsed chunk.
+ * @param format - Module format selecting ESM vs CJS export/import shapes.
+ * @returns The chunk model consumed by {@link computeKeepClosure}.
+ *
+ * @example Modeling an ESM chunk
+ * ```typescript
+ * const model = analyzeChunk(parseChunk(source), 'esm')
+ * ```
+ */
+const analyzeChunk = (sourceFile, format) => {
+    const nameToDecl = createMap();
+    const decls = [];
+    const importStatements = [];
+    // why: not named `exports` — a local `exports` shadows the module object, breaking the transpiled `(0, exports.collectBindingCanonical)` reference under isolatedModules CJS.
+    const exportEntries = [];
+    const exportSurfaceStatements = createSet([]);
+    const resolution = collectBindingCanonical(sourceFile);
+    for (const statement of sourceFile.statements) {
+        if (format === 'esm' ? ts.isImportDeclaration(statement) : isRequireVarStatement(statement)) {
+            importStatements.push(statement);
+            continue;
+        }
+        const decl = tryDecl(statement, resolution);
+        if (decl) {
+            decls.push(decl);
+            for (const name of decl.names)
+                nameToDecl.set(name, decl);
+        }
+        if (format === 'esm')
+            collectEsmExports(statement, exportEntries, exportSurfaceStatements);
+        else
+            collectCjsExports(statement, exportEntries, exportSurfaceStatements);
+    }
+    return { nameToDecl, decls, importStatements, exports: exportEntries, exportSurfaceStatements };
+};
+const collectRoots = (sourceFile, model, keep, declStatements) => {
+    const roots = createSet([]);
+    for (const entry of model.exports)
+        if (keep.has(entry.exported))
+            roots.add(entry.local);
+    for (const decl of model.decls)
+        if (!decl.sideEffectFree)
+            for (const name of decl.names)
+                roots.add(name);
+    for (const statement of sourceFile.statements) {
+        if (declStatements.has(statement) || model.exportSurfaceStatements.has(statement) || model.importStatements.includes(statement))
+            continue;
+        collectRefs(statement, roots);
+    }
+    return roots;
+};
+/**
+ * Computes the closure of local declaration names that must be retained: every
+ * kept export, every side-effecting declaration, every name referenced by a
+ * bare top-level statement, and everything those transitively reference.
+ *
+ * @param sourceFile - The parsed chunk.
+ * @param model - The chunk model from {@link analyzeChunk}.
+ * @param keep - Exported names demanded by importers.
+ * @returns The set of local names that may not be removed.
+ *
+ * @example Names that survive given a one-export demand
+ * ```typescript
+ * const live = computeKeepClosure(sourceFile, model, createSet(['getType']))
+ * ```
+ */
+const computeKeepClosure = (sourceFile, model, keep) => {
+    const declStatements = createSet(model.decls.map((decl) => decl.statement));
+    const refsCache = createMap();
+    const refsOf = (statement) => {
+        const cached = refsCache.get(statement);
+        if (cached)
+            return cached;
+        const refs = createSet([]);
+        collectRefs(statement, refs);
+        refsCache.set(statement, refs);
+        return refs;
+    };
+    const keepClosure = createSet([]);
+    const stack = from(collectRoots(sourceFile, model, keep, declStatements));
+    while (stack.length > 0) {
+        const name = stack.pop();
+        if (keepClosure.has(name))
+            continue;
+        keepClosure.add(name);
+        const decl = model.nameToDecl.get(name);
+        if (!decl)
+            continue;
+        for (const ref of refsOf(decl.statement))
+            if (!keepClosure.has(ref))
+                stack.push(ref);
+    }
+    return keepClosure;
+};
+
+/**
+ * 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$1 = (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$1(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$1(parsed.sourceFile.text, [...deletions, { start: parsed.headerEnd, end: parsed.headerEnd, text: insertion }]);
+};
+
+const log$6 = 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$2(baseDir, specifier))) : specifier;
+const locateEntries = (context, format) => {
+    const locations = [];
+    for (const entry of context.entryPointDiscovery.entryPoints) {
+        const dir = entryDirOf(entry, context);
+        const file = join$2(dir, chunkFileName(format));
+        if (exists(file))
+            locations.push({ dir, file });
+    }
+    return locations;
+};
+const chunkFileFor = (context, moduleKey, format) => join$2(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$2(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$2 = (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$2(context.projectRoot, 'src');
+    if (!exists(srcRoot))
+        return report;
+    const owners = indexOwners(srcRoot);
+    for (const format of FORMATS) {
+        processFormat$2(context, owners, format, report);
+        monitor?.check(`bundle:dedupe:shared-first-party:${format}:end`);
+    }
+    if (report.chunksWritten > 0)
+        log$6.info(`hoisted ${report.chunksWritten} shared chunk(s), reclaimed ${report.bytesReclaimed} byte(s)`);
+    return report;
+};
+
+/**
+ * Applies text-range edits to a chunk source by splicing each span in
+ * descending start order, so every edit's offsets stay valid against the
+ * original source regardless of the order they are passed in. All offsets must
+ * refer to the original `source`, and spans must not overlap. The input `edits`
+ * array is copied before sorting, so the caller's order is left untouched.
+ *
+ * @param source - Original chunk source text.
+ * @param edits - Edits to apply; their relative order does not matter.
+ * @param collapseBlankLines - When `true`, runs of three or more newlines left
+ * behind by whole-statement splices are collapsed to a single blank line so the
+ * trimmed chunk stays readable. Defaults to `false`.
+ * @returns The rewritten source.
+ *
+ * @example Deleting a statement and collapsing the blank run it leaves
+ * ```typescript
+ * applyEdits(source, [{ start, end, text: '' }], true)
+ * ```
+ */
+const applyEdits = (source, edits, collapseBlankLines = false) => {
+    let code = source;
+    for (const edit of [...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 chunk stays readable.
+    return collapseBlankLines ? code.replace(/\n{3,}/g, '\n\n') : code;
+};
+
+const renderEsmExportList = (entries) => `export { ${entries.map((entry) => (entry.exported === entry.local ? entry.local : `${entry.local} as ${entry.exported}`)).join(', ')} };`;
+const renderEsmImport = (elements, specifierText) => {
+    const bindings = elements.map((element) => {
+        const imported = (element.propertyName ?? element.name).text;
+        return imported === element.name.text ? imported : `${imported} as ${element.name.text}`;
+    });
+    return `import { ${bindings.join(', ')} } from ${specifierText};`;
+};
+const narrowEsmImport = (statement, usedNames, sourceFile, edits) => {
+    const clause = statement.importClause;
+    // why: default and namespace imports bind the whole module object — never narrowed.
+    if (!clause || clause.name || !clause.namedBindings || !ts.isNamedImports(clause.namedBindings))
+        return;
+    const surviving = clause.namedBindings.elements.filter((element) => usedNames.has(element.name.text));
+    if (surviving.length === clause.namedBindings.elements.length)
+        return;
+    if (surviving.length === 0)
+        edits.push({ start: statement.getFullStart(), end: statement.getEnd(), text: '' });
+    else
+        edits.push({
+            start: statement.getStart(sourceFile),
+            end: statement.getEnd(),
+            text: renderEsmImport(surviving, statement.moduleSpecifier.getText(sourceFile)),
+        });
+};
+const narrowCjsRequire = (statement, usedNames, edits) => {
+    const locals = requireBindingLocals(statement);
+    if (locals.length > 0 && locals.every((local) => !usedNames.has(local)))
+        edits.push({ start: statement.getFullStart(), end: statement.getEnd(), text: '' });
+};
+const collectExportEdits = (exports$1, removedLocals, sourceFile, edits) => {
+    const listGroups = createMap();
+    for (const entry of exports$1) {
+        if (entry.kind === 'cjs-assign' && removedLocals.has(entry.local))
+            edits.push({ start: entry.statement.getFullStart(), end: entry.statement.getEnd(), text: '' });
+        if (entry.kind !== 'esm-list')
+            continue;
+        const group = listGroups.get(entry.statement) ?? [];
+        group.push(entry);
+        listGroups.set(entry.statement, group);
+    }
+    for (const [statement, group] of listGroups) {
+        const surviving = group.filter((entry) => !removedLocals.has(entry.local));
+        if (surviving.length === group.length)
+            continue;
+        if (surviving.length === 0)
+            edits.push({ start: statement.getFullStart(), end: statement.getEnd(), text: '' });
+        else
+            edits.push({ start: statement.getStart(sourceFile), end: statement.getEnd(), text: renderEsmExportList(surviving) });
+    }
+};
+/**
+ * Removes guaranteed-dead exported declarations (and the now-dead private code
+ * and imports they pulled in) from a single chunk's source.
+ *
+ * Builds the chunk's declaration/export model, computes the keep-closure from
+ * the importer-supplied `keep` demand, and splices out every side-effect-free
+ * top-level declaration that no kept declaration, kept export, or bare
+ * side-effecting statement references. The matching entries are dropped from the
+ * export surface, and import bindings left unreferenced by the surviving code are
+ * narrowed away (whole import statements when fully unused) — which is what
+ * shrinks the cross-chunk dependency graph for the next fixpoint pass.
+ * Side-effecting initializers and bare statements are always kept.
+ *
+ * @param source - Raw chunk source text.
+ * @param format - Module format of the chunk.
+ * @param keep - Exported names importers demand, or `'all'` to keep everything.
+ * @returns The rewritten source and removed export names, or `null` when nothing
+ * could be removed.
+ *
+ * @example Stripping all but one export from a chunk
+ * ```typescript
+ * stripDeadExports(source, 'esm', createSet(['getType']))
+ * ```
+ */
+const stripDeadExports = (source, format, keep) => {
+    if (keep === 'all')
+        return null;
+    const sourceFile = parseChunk(source);
+    const model = analyzeChunk(sourceFile, format);
+    const keepClosure = computeKeepClosure(sourceFile, model, keep);
+    const removableDecls = model.decls.filter((decl) => decl.sideEffectFree && decl.names.every((name) => !keepClosure.has(name)));
+    if (removableDecls.length === 0)
+        return null;
+    const removedLocals = createSet([]);
+    for (const decl of removableDecls)
+        for (const name of decl.names)
+            removedLocals.add(name);
+    const removeSet = createSet(removableDecls.map((decl) => decl.statement));
+    const removedNames = createSet([]);
+    for (const entry of model.exports)
+        if (removedLocals.has(entry.local))
+            removedNames.add(entry.exported);
+    const usedNames = createSet([]);
+    for (const statement of sourceFile.statements) {
+        if (model.importStatements.includes(statement) || removeSet.has(statement))
+            continue;
+        collectRefs(statement, usedNames);
+    }
+    const edits = removableDecls.map((decl) => ({ start: decl.statement.getFullStart(), end: decl.statement.getEnd(), text: '' }));
+    collectExportEdits(model.exports, removedLocals, sourceFile, edits);
+    for (const statement of model.importStatements) {
+        if (format === 'esm')
+            narrowEsmImport(statement, usedNames, sourceFile, edits);
+        else
+            narrowCjsRequire(statement, usedNames, edits);
+    }
+    return { code: applyEdits(source, edits, true), removedNames: from(removedNames) };
+};
+
+const log$5 = logger.channel('builder:bundle:dependencies:prune');
+/**
+ * Computes the set of files reachable from a set of root files by following
+ * literal relative specifiers, restricted to targets under `depsRoot`.
+ *
+ * Targets that resolve outside `depsRoot` (the package's own non-dependency
+ * code) are ignored; the roots themselves are always included so callers can use
+ * the returned set as a single live-membership oracle.
+ *
+ * If a reached file **under `depsRoot`** contains a dynamic (non-literal)
+ * `import(`/`require(`, the dependency chunk graph cannot be fully resolved, so
+ * the function logs and returns `null` — the guaranteed-safe sentinel that
+ * disables orphan deletion for the run. A dynamic specifier in a first-party
+ * **root** (which is never under `depsRoot`) is ignored: its target is always an
+ * external/user path, never a bundled dep chunk, so it cannot hide a
+ * `_dependencies/` edge — bailing on it would needlessly strand emptied dep
+ * chunks the sweep should reclaim.
+ *
+ * @param roots - Absolute paths to the root files reachability starts from.
+ * @param depsRoot - Absolute path to the `_dependencies/` directory; traversal
+ * never leaves it.
+ * @param resolveTarget - Maps each resolved specifier target before it is
+ * visited; defaults to identity. The d.ts pass passes a mapper that rewrites a
+ * runtime specifier (`'.../index.js'`) to its declaration sibling
+ * (`'.../index.d.ts'`) so traversal follows the type graph, never the runtime
+ * graph.
+ * @returns The set of reachable absolute file paths, or `null` when a dynamic
+ * specifier forces a safety bail.
+ *
+ * @example Reachability from an ESM entry chunk
+ * ```typescript
+ * const live = computeReachable(['/dist/libs/foo/index.esm.js'], '/dist/libs/foo/_dependencies')
+ * if (live && !live.has(orphanChunk)) unlinkSync(orphanChunk)
+ * ```
+ */
+const computeReachable = (roots, depsRoot, resolveTarget = (target) => target) => {
+    const reachable = createSet([]);
+    const queue = [];
+    for (const root of roots) {
+        if (exists(root) && !reachable.has(root)) {
+            reachable.add(root);
+            queue.push(root);
+        }
+    }
+    let head = 0;
+    while (head < queue.length) {
+        const file = queue[head];
+        head += 1;
+        const source = readFileContent(file);
+        // why: a dynamic specifier only threatens the sweep when it sits in a `_dependencies/` chunk, where it can hide an intra-deps edge to a sibling chunk we'd otherwise delete. First-party entry roots legitimately carry dynamic `import(<expr>)` (e.g. runtime config loading) whose targets are always external user paths — never bundled dep chunks — so bailing on those needlessly disables the entire sweep and strands emptied dep chunks. Roots are never under `depsRoot` (collectEntryFiles excludes them), so this scopes the bail to dep chunks only.
+        if (isUnderDir(file, depsRoot) && hasDynamicSpecifier(source)) {
+            log$5.warn(`dynamic import/require in ${file}; skipping dependency orphan prune for safety`);
+            return null;
+        }
+        const dir = getDirname(file);
+        for (const spec of collectChunkSpecifiers(source)) {
+            const target = resolveTarget(join$2(dir, spec));
+            if (isUnderDir(target, depsRoot) && exists(target) && !reachable.has(target)) {
+                reachable.add(target);
+                queue.push(target);
+            }
+        }
+    }
+    return reachable;
+};
+
+/**
+ * Resolves the package's own entry output files for the given file names,
+ * skipping any entry directory that resolves at or under `_dependencies/`.
+ *
+ * These are the reachability/usage roots: the chunks a consumer's package entry
+ * points actually load, from which dependency code is reached.
+ *
+ * @param context - Resolved build context supplying the entry points.
+ * @param depsRoot - Absolute path to the `_dependencies/` directory.
+ * @param fileNames - Output file names to look for in each entry directory
+ * (e.g. `['index.esm.js']`).
+ * @returns Absolute paths of every entry file that exists on disk.
+ *
+ * @example Collecting ESM entry roots
+ * ```typescript
+ * const roots = collectEntryFiles(context, depsRoot, ['index.esm.js'])
+ * ```
+ */
+const collectEntryFiles = (context, depsRoot, fileNames) => {
+    const files = [];
+    for (const entry of context.entryPointDiscovery.entryPoints) {
+        const dir = entryDirOf(entry, context);
+        if (isUnderDir(dir, depsRoot))
+            continue;
+        for (const name of fileNames) {
+            const candidate = join$2(dir, name);
+            if (exists(candidate))
+                files.push(candidate);
+        }
+    }
+    return files;
+};
+/**
+ * Recursively collects file paths under `dir` whose base name satisfies
+ * `matches`, appending them to `acc`.
+ *
+ * @param dir - Directory to walk; assumed to exist (the `_dependencies/` root or
+ * a directory yielded by `readDirectory`).
+ * @param matches - Predicate over a file's base name.
+ * @param acc - Accumulator that receives every matching absolute path.
+ *
+ * @example Gathering every ESM chunk
+ * ```typescript
+ * const chunks: string[] = []
+ * walkFiles(depsRoot, (name) => name === 'index.esm.js', chunks)
+ * ```
+ */
+const walkFiles = (dir, matches, acc) => {
+    // why: only ever called on the validated `_dependencies/` root or a directory from `readDirectory`, so the target always exists — no existence guard needed.
+    for (const entry of readDirectory(dir)) {
+        if (entry.isDirectory)
+            walkFiles(entry.path, matches, acc);
+        else if (matches(entry.name))
+            acc.push(entry.path);
+    }
+};
+const unlinkWithMap = (path) => {
+    // why: the caller only passes paths it just enumerated from disk, so statSync never misses.
+    let bytesRemoved = statSync(path).size;
+    let orphanFilesRemoved = 1;
+    unlinkSync(path);
+    const mapPath = `${path}.map`;
+    if (exists(mapPath)) {
+        bytesRemoved += statSync(mapPath).size;
+        unlinkSync(mapPath);
+        orphanFilesRemoved += 1;
+    }
+    return { orphanFilesRemoved, bytesRemoved };
+};
+const pruneJsOrphans = (context, depsRoot) => {
+    const roots = collectEntryFiles(context, depsRoot, ['index.esm.js', 'index.cjs.js']);
+    const reachable = computeReachable(roots, depsRoot);
+    const chunks = [];
+    walkFiles(depsRoot, (name) => name === 'index.esm.js' || name === 'index.cjs.js', chunks);
+    // why: a dynamic-specifier bail keeps every chunk.
+    if (reachable === null)
+        return { orphanFilesRemoved: 0, bytesRemoved: 0 };
+    let orphanFilesRemoved = 0;
+    let bytesRemoved = 0;
+    for (const chunk of chunks) {
+        if (reachable.has(chunk))
+            continue;
+        const removed = unlinkWithMap(chunk);
+        orphanFilesRemoved += removed.orphanFilesRemoved;
+        bytesRemoved += removed.bytesRemoved;
+    }
+    return { orphanFilesRemoved, bytesRemoved };
+};
+// why: declaration specifiers carry the runtime extension (`'.../index.js'`, also `.esm.js`/`.cjs.js`); a d.ts type-reference resolves to the sibling `index.d.ts`, so the type-graph walk must rewrite the target before visiting it.
+const toDtsTarget = (target) => target.replace(/(?:\.esm|\.cjs)?\.[mc]?js$/, '.d.ts');
+const pruneDtsOrphans = (context, depsRoot) => {
+    const roots = collectEntryFiles(context, depsRoot, ['index.d.ts']);
+    const reachable = computeReachable(roots, depsRoot, toDtsTarget);
+    const chunks = [];
+    walkFiles(depsRoot, (name) => name === 'index.d.ts', chunks);
+    // why: a dynamic specifier in the type graph cannot be resolved — keep every dep d.ts (guaranteed-safe fallback), mirroring the JS sweep.
+    if (reachable === null)
+        return { orphanFilesRemoved: 0, bytesRemoved: 0 };
+    let orphanFilesRemoved = 0;
+    let bytesRemoved = 0;
+    for (const chunk of chunks) {
+        // why: keep a dep's types only when an entry's own d.ts type-graph reaches them — the dts-per-entry pass makes each entry `index.d.ts` self-contained, so any dep d.ts no entry type-graph references is dead.
+        if (reachable.has(chunk))
+            continue;
+        const removed = unlinkWithMap(chunk);
+        orphanFilesRemoved += removed.orphanFilesRemoved;
+        bytesRemoved += removed.bytesRemoved;
+    }
+    return { orphanFilesRemoved, bytesRemoved };
+};
+/**
+ * Orphan Sweep: deletes `_dependencies/**` chunk files that no package entry
+ * reaches.
+ *
+ * Runs reachability from the package's own entry output chunks over the
+ * `_dependencies/` JS graph, unlinks every `index.{esm,cjs}.js` (and `.map`
+ * sibling) that is unreachable, then applies the d.ts retention rule — a dep's
+ * `index.d.ts` is kept only when it is reachable from an entry's `.d.ts` graph.
+ * Entry `index.d.ts` are self-contained (dts-per-entry), so dep types no entry
+ * type-graph references are dead and removed. Empty directories left behind are
+ * removed. A dynamic, non-literal `import(`/`require(` anywhere in the reachable
+ * graph disables deletion entirely (guaranteed-safe fallback).
+ *
+ * @param context - Resolved build context.
+ * @param depsRoot - Absolute path to the `_dependencies/` directory.
+ * @returns Aggregate count of files removed and bytes reclaimed.
+ *
+ * @example Sweeping orphans after the per-entry d.ts pass
+ * ```typescript
+ * const { orphanFilesRemoved } = pruneOrphanChunks(context, depsRootOf(context))
+ * ```
+ */
+const pruneOrphanChunks = (context, depsRoot) => {
+    if (!exists(depsRoot) || !isDirectory(depsRoot))
+        return { orphanFilesRemoved: 0, bytesRemoved: 0 };
+    const js = pruneJsOrphans(context, depsRoot);
+    const dts = pruneDtsOrphans(context, depsRoot);
+    // why: shares the package-wide empty-dir helper; `depsRoot` itself is left intact, matching the prior `cleanupEmptyDirs` behavior.
+    removeEmptyDirs(depsRoot);
+    return {
+        orphanFilesRemoved: js.orphanFilesRemoved + dts.orphanFilesRemoved,
+        bytesRemoved: js.bytesRemoved + dts.bytesRemoved,
+    };
+};
+
+const mergeName = (edges, target, name) => {
+    const current = edges.get(target);
+    if (current === 'all')
+        return;
+    if (current)
+        current.add(name);
+    else
+        edges.set(target, createSet([name]));
+};
+const mergeAll = (edges, target) => void edges.set(target, 'all');
+// why: a side-effect-only import (`import './x'`) reaches a chunk without naming any export; record it with an empty demand so the orphan re-sweep, not the export stripper, decides its fate.
+const markReached = (edges, target) => void (edges.has(target) || edges.set(target, createSet([])));
+const collectEsmEdges = (sourceFile, importerDir, edges) => {
+    for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement)) {
+            // why: an `ImportDeclaration`'s module specifier is always a string literal in parseable source.
+            const target = resolveRelativeTarget(importerDir, statement.moduleSpecifier.text);
+            if (target === null)
+                continue;
+            const clause = statement.importClause;
+            if (!clause) {
+                markReached(edges, target);
+                continue;
+            }
+            // why: `import def from 'F'` pulls the default export — consume the whole surface to stay safe.
+            if (clause.name) {
+                mergeAll(edges, target);
+                continue;
+            }
+            // why: with no default binding, a parseable import always carries named bindings — either `* as ns` or `{ … }`.
+            const bindings = clause.namedBindings;
+            if (ts.isNamespaceImport(bindings)) {
+                mergeAll(edges, target);
+                continue;
+            }
+            for (const element of bindings.elements)
+                mergeName(edges, target, (element.propertyName ?? element.name).text);
+            continue;
+        }
+        if (ts.isExportDeclaration(statement) && statement.moduleSpecifier) {
+            // why: a re-export's module specifier, when present, is always a string literal in parseable source.
+            const target = resolveRelativeTarget(importerDir, statement.moduleSpecifier.text);
+            if (target === null)
+                continue;
+            // why: `export * from 'F'` re-exports the entire surface — treat as wholesale demand.
+            if (!statement.exportClause || !ts.isNamedExports(statement.exportClause)) {
+                mergeAll(edges, target);
+                continue;
+            }
+            for (const element of statement.exportClause.elements)
+                mergeName(edges, target, (element.propertyName ?? element.name).text);
+        }
+    }
+};
+const collectCjsBindingEdges = (node, target, edges, namespaceBindings, declNames) => {
+    const shape = classifyRequireBinding(node);
+    switch (shape.kind) {
+        case 'prop':
+            mergeName(edges, target, shape.name);
+            return;
+        // why: inline element access (`require('./x')['foo']`, static or computed) keeps the whole chunk — this pass never narrowed it, and preserving that is safe (the namespace-usage pass narrows the static case). Narrowing here would be a separate enhancement.
+        case 'elem-static':
+        case 'elem-dynamic':
+            mergeAll(edges, target);
+            return;
+        // why: a bare `require('./x')` statement pulls the chunk only for its side effects, naming no export; record it reached with empty demand — mirroring an ESM side-effect import — so the orphan re-sweep, not the export stripper, decides its fate.
+        case 'side-effect':
+            markReached(edges, target);
+            return;
+        case 'ns-binding':
+            namespaceBindings.set(shape.name.text, target);
+            declNames.add(shape.name);
+            return;
+        case 'destructure':
+            for (const element of shape.pattern.elements) {
+                // why: a rest element (`...rest`) captures every remaining export, so the surface must be kept whole.
+                if (element.dotDotDotToken) {
+                    mergeAll(edges, target);
+                    continue;
+                }
+                const key = element.propertyName ?? element.name;
+                if (ts.isIdentifier(key) || ts.isStringLiteralLike(key))
+                    mergeName(edges, target, key.text);
+                else
+                    mergeAll(edges, target);
+            }
+            return;
+        // why: a `require` used as a call argument, spread, or any non-binding position escapes member tracking — keep the whole chunk.
+        case 'escape':
+            mergeAll(edges, target);
+            return;
+    }
+};
+const scanNamespaceUse = (identifier, namespaceBindings, edges, declNames) => {
+    const target = namespaceBindings.get(identifier.text);
+    if (target === undefined || declNames.has(identifier))
+        return;
+    const parent = identifier.parent;
+    if (ts.isPropertyAccessExpression(parent) && parent.expression === identifier && ts.isIdentifier(parent.name)) {
+        mergeName(edges, target, parent.name.text);
+        return;
+    }
+    if (ts.isElementAccessExpression(parent) && parent.expression === identifier) {
+        if (ts.isStringLiteralLike(parent.argumentExpression))
+            mergeName(edges, target, parent.argumentExpression.text);
+        else
+            mergeAll(edges, target);
+        return;
+    }
+    // why: the binding name appearing as another object's property key is unrelated; every other position is a wholesale escape.
+    if (!(ts.isPropertyAccessExpression(parent) && parent.name === identifier))
+        mergeAll(edges, target);
+};
+const collectCjsEdges = (sourceFile, importerDir, edges) => {
+    const namespaceBindings = createMap();
+    const declNames = createSet([]);
+    const findRequires = (node) => {
+        const specifier = getRequireSpecifier(node);
+        if (specifier !== null) {
+            const target = resolveRelativeTarget(importerDir, specifier);
+            if (target !== null)
+                collectCjsBindingEdges(node, target, edges, namespaceBindings, declNames);
+        }
+        ts.forEachChild(node, findRequires);
+    };
+    findRequires(sourceFile);
+    if (namespaceBindings.size === 0)
+        return;
+    const scanUses = (node) => {
+        if (ts.isIdentifier(node))
+            scanNamespaceUse(node, namespaceBindings, edges, declNames);
+        ts.forEachChild(node, scanUses);
+    };
+    scanUses(sourceFile);
+};
+/**
+ * Builds the map of chunk → exported-name demand for every relative module edge
+ * a single importer declares.
+ *
+ * Each key is the absolute path the importer references; each value is the set
+ * of exported names it pulls from that chunk, or `'all'` when the reference is
+ * wholesale (namespace/default import, `export *`, or a `require` binding that
+ * escapes member access). A side-effect-only `import './x'` records the target
+ * with an empty set.
+ *
+ * @param source - Raw importer source text.
+ * @param importerDir - Absolute directory of the importer file.
+ * @param format - Module format that determines ESM vs CJS edge extraction.
+ * @returns Map from resolved chunk path to its usage demand.
+ *
+ * @example Edges of an ESM entry
+ * ```typescript
+ * collectImportEdges("import { getType } from './_dependencies/x/index.esm.js'", '/dist/libs/foo', 'esm')
+ * // => Map { '/dist/libs/foo/_dependencies/x/index.esm.js' => Set { 'getType' } }
+ * ```
+ */
+const collectImportEdges = (source, importerDir, format) => {
+    const sourceFile = parseChunk(source);
+    const edges = createMap();
+    if (format === 'esm')
+        collectEsmEdges(sourceFile, importerDir, edges);
+    else
+        collectCjsEdges(sourceFile, importerDir, edges);
+    return edges;
+};
+
+const log$4 = logger.channel('builder:bundle:dependencies:prune');
+// why: the strip → re-derive → strip cycle converges in passes bounded by the chunk-import depth; this cap is a runaway guard, logged if ever reached.
+const MAX_ITERATIONS = 50;
+const FORMAT_FILES$1 = [
+    { format: 'esm', fileName: 'index.esm.js' },
+    { format: 'cjs', fileName: 'index.cjs.js' },
+];
+const mergeUsage = (usageMap, target, usage) => {
+    const current = usageMap.get(target);
+    // why: targets outside the surviving-chunk set are the package's own code — not strippable, so ignore their demand.
+    if (current === undefined || current === 'all')
+        return;
+    if (usage === 'all') {
+        usageMap.set(target, 'all');
+        return;
+    }
+    for (const name of usage)
+        current.add(name);
+};
+const buildUsageMap = (importers, chunks, format) => {
+    const usageMap = createMap();
+    for (const chunk of chunks)
+        usageMap.set(chunk, createSet([]));
+    // why: every importer is either a validated entry file or a chunk just walked off disk, so all are present — no existence guard needed.
+    for (const importer of importers) {
+        for (const [target, usage] of collectImportEdges(readFileContent(importer), getDirname(importer), format))
+            mergeUsage(usageMap, target, usage);
+    }
+    return usageMap;
+};
+const stripChunks = (usageMap, format, result) => {
+    let changed = false;
+    for (const [chunk, keep] of usageMap) {
+        const source = readFileContent(chunk);
+        const stripped = stripDeadExports(source, format, keep);
+        if (!stripped)
+            continue;
+        writeFileContent(chunk, stripped.code);
+        result.deadExportsRemoved += stripped.removedNames.length;
+        result.bytesRemoved += Buffer.byteLength(source) - Buffer.byteLength(stripped.code);
+        changed = true;
+    }
+    return changed;
+};
+const processFormat$1 = (context, depsRoot, format, fileName, result) => {
+    const entries = collectEntryFiles(context, depsRoot, [fileName]);
+    for (let iteration = 0; iteration < MAX_ITERATIONS; iteration += 1) {
+        const chunks = [];
+        walkFiles(depsRoot, (name) => name === fileName, chunks);
+        if (chunks.length === 0)
+            return;
+        const usageMap = buildUsageMap([...entries, ...chunks], chunks, format);
+        if (!stripChunks(usageMap, format, result))
+            return;
+        // istanbul ignore next -- why: convergence exits via the early return above; a >50-deep chunk import chain that would exhaust the cap cannot occur in bundled dependency output, so the guard log is unreachable in practice.
+        if (iteration === MAX_ITERATIONS - 1)
+            log$4.warn(`dead-export strip for ${format} hit the ${MAX_ITERATIONS}-iteration cap before converging`);
+    }
+};
+/**
+ * Shrinks surviving `_dependencies/` chunks by stripping dead exported
+ * declarations, iterating to a fixpoint per format.
+ *
+ * Each iteration re-derives the importer demand for every surviving chunk from
+ * the current on-disk sources (entries plus sibling chunks), strips each chunk
+ * to that demand, and repeats until no chunk changes — because removing one
+ * chunk's import can make another chunk's export dead in turn. ESM and CJS are
+ * processed independently. The orphan sweep is expected to run afterwards to
+ * reclaim any chunk whose last import was removed here.
+ *
+ * @param context - Resolved build context supplying the entry points.
+ * @param depsRoot - Absolute path to the `_dependencies/` directory.
+ * @returns Counts of exports removed and bytes reclaimed.
+ *
+ * @example Running the strip pass after the orphan sweep
+ * ```typescript
+ * const { deadExportsRemoved } = stripDeadExportsPass(context, depsRootOf(context))
+ * ```
+ */
+const stripDeadExportsPass = (context, depsRoot) => {
+    const result = { deadExportsRemoved: 0, bytesRemoved: 0 };
+    if (!exists(depsRoot))
+        return result;
+    for (const { format, fileName } of FORMAT_FILES$1)
+        processFormat$1(context, depsRoot, format, fileName, result);
+    return result;
+};
+
+// why: an identifier is a free reference or a binding name unless it sits in a member-name / object-key position, where it never introduces or reads a top-level-visible name. The reserved set is what new destructured locals must avoid colliding with.
+const isNameOnlyPosition = (id) => {
+    const parent = id.parent;
+    if (ts.isPropertyAccessExpression(parent) && parent.name === id)
+        return true;
+    if (ts.isPropertyAssignment(parent) && parent.name === id)
+        return true;
+    if (ts.isBindingElement(parent) && parent.propertyName === id)
+        return true;
+    return false;
+};
+const collectReserved = (sourceFile, bindingNodes) => {
+    const reserved = createSet([]);
+    const visit = (node) => {
+        // why: a candidate's own binding name is being removed, so it never blocks a chosen local.
+        if (ts.isIdentifier(node) && !bindingNodes.has(node) && !isNameOnlyPosition(node))
+            reserved.add(node.text);
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return reserved;
+};
+const collectCandidates = (sourceFile, chunkDir, isSafeTarget) => {
+    const candidates = createMap();
+    const seen = createSet([]);
+    const visit = (node) => {
+        const specifier = getRequireSpecifier(node);
+        if (specifier !== null) {
+            const target = resolveRelativeTarget(chunkDir, specifier);
+            const parent = node.parent;
+            // why: when a `require` call's direct parent is a `VariableDeclaration`, the call is necessarily its initializer (a declaration's only expression child), so no separate initializer check is needed.
+            if (target !== null && isSafeTarget(target) && ts.isVariableDeclaration(parent) && ts.isIdentifier(parent.name)) {
+                const local = parent.name.text;
+                // why: a local bound twice cannot be tracked unambiguously by text scan — drop it from consideration entirely.
+                if (seen.has(local))
+                    candidates.delete(local);
+                else {
+                    seen.add(local);
+                    candidates.set(local, { local, nameNode: parent.name, members: createMap(), bail: false });
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return candidates;
+};
+// why: a destructure shorthand `const { name } = require(...)` is legal only when `name` is a real BindingIdentifier — so lex `name` whole. A single `Identifier` followed by end-of-input proves it: a keyword (`default`, and strict-reserved `let`/`yield`/`static`/`await`, illegal in rollup's strict CJS) lexes to its own keyword token, not `Identifier`; a non-identifier key (`foo-bar` from `NS["foo-bar"]`) lexes to `Identifier` + more tokens, so the EOF check fails. Over-bailing a rare contextual export name (`as`/`type`) is safe: it keeps the namespace form, which is valid.
+const isValidBindingName = (name) => {
+    const scanner = ts.createScanner(ts.ScriptTarget.ESNext, /*skipTrivia*/ true, ts.LanguageVariant.Standard, name);
+    return scanner.scan() === ts.SyntaxKind.Identifier && scanner.scan() === ts.SyntaxKind.EndOfFileToken;
+};
+const scanUses = (sourceFile, candidates, bindingNodes) => {
+    const visit = (node) => {
+        if (ts.isIdentifier(node) && !bindingNodes.has(node)) {
+            const candidate = candidates.get(node.text);
+            if (candidate && !candidate.bail) {
+                const classification = classifyNamespaceUse(node);
+                // why: a member named by a non-identifier (`m['foo-bar']`) or a keyword (`m.default`) cannot be destructured to a legal `const { … }` binding — bail the whole candidate to its namespace form rather than emit invalid JS.
+                if (classification.kind === 'bail' || (classification.kind === 'read' && !isValidBindingName(classification.prop)))
+                    candidate.bail = true;
+                else if (classification.kind === 'read') {
+                    const nodes = candidate.members.get(classification.prop) ?? [];
+                    nodes.push(node.parent);
+                    candidate.members.set(classification.prop, nodes);
+                }
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+};
+const renderBindingPattern = (assignments) => `{ ${assignments.map(({ exported, local }) => (exported === local ? exported : `${exported}: ${local}`)).join(', ')} }`;
+const allocateLocal = (exported, taken) => {
+    if (!taken.has(exported))
+        return exported;
+    let suffix = 1;
+    while (taken.has(`${exported}$${suffix}`))
+        suffix += 1;
+    return `${exported}$${suffix}`;
+};
+/**
+ * Rewrites whole-module CJS require bindings to destructuring binds when the
+ * binding is consumed only as static member reads.
+ *
+ * For every top-level `const NS = require('./rel')` whose target `isSafeTarget`
+ * accepts (a relative sibling chunk that is provably not in a `require` cycle
+ * with this chunk), and where `NS` is used exclusively as `NS.member` /
+ * `NS['member']` reads, the binding is collapsed to `const { member, … } =
+ * require('./rel')` and each `NS.member` access is replaced by the bound local.
+ * Locals that would collide with an existing free identifier or another bound
+ * local are aliased (`member: member$1`) — so the rewrite never shadows the
+ * chunk's own names. Any wholesale, dynamic, or reassigning use of `NS` leaves
+ * its binding untouched, matching rollup's namespace-access codegen.
+ *
+ * The cycle guard is the caller's responsibility: rollup keeps the namespace
+ * form precisely so an eager destructure cannot capture an export before a
+ * circular dependency has initialized it. Passing only acyclic targets to
+ * `isSafeTarget` preserves that guarantee.
+ *
+ * @param source - Raw CJS chunk source text.
+ * @param chunkDir - Absolute directory of the chunk, for resolving relative requires.
+ * @param isSafeTarget - Predicate selecting which resolved require targets may be destructured.
+ * @returns The rewritten source and the count of bindings destructured, or `null`
+ * when no binding qualified.
+ *
+ * @example Destructuring a single-member require
+ * ```typescript
+ * destructureRequires("const m = require('./math/index.cjs.js');\nm.abs(x);", '/d/p', () => true)
+ * // => { code: "const { abs } = require('./math/index.cjs.js');\nabs(x);", rewrittenBindings: 1 }
+ * ```
+ */
+const destructureRequires = (source, chunkDir, isSafeTarget) => {
+    const sourceFile = parseChunk(source);
+    const candidates = collectCandidates(sourceFile, chunkDir, isSafeTarget);
+    if (candidates.size === 0)
+        return null;
+    const bindingNodes = createSet([...candidates.values()].map((candidate) => candidate.nameNode));
+    scanUses(sourceFile, candidates, bindingNodes);
+    const qualified = [...candidates.values()].filter((candidate) => !candidate.bail && candidate.members.size > 0);
+    if (qualified.length === 0)
+        return null;
+    // why: every binding being collapsed frees its own name, so exclude binding nodes; new locals must dodge all other free identifiers.
+    const taken = collectReserved(sourceFile, bindingNodes);
+    const edits = [];
+    for (const candidate of qualified) {
+        const assignments = [];
+        for (const exported of [...candidate.members.keys()].sort()) {
+            const local = allocateLocal(exported, taken);
+            taken.add(local);
+            assignments.push({ exported, local });
+            // why: the member-access node (`NS.member` or `NS['member']`) collapses to the bound local; the key came from this same map, so the lookup always resolves.
+            for (const accessNode of candidate.members.get(exported))
+                edits.push({ start: accessNode.getStart(sourceFile), end: accessNode.getEnd(), text: local });
+        }
+        edits.push({
+            start: candidate.nameNode.getStart(sourceFile),
+            end: candidate.nameNode.getEnd(),
+            text: renderBindingPattern(assignments),
+        });
+    }
+    return { code: applyEdits(source, edits), rewrittenBindings: qualified.length };
+};
+
+const log$3 = logger.channel('builder:bundle:dependencies:prune');
+const CJS_CHUNK = 'index.cjs.js';
+const collectRequireTargets = (source, chunkDir, chunkSet) => {
+    const sourceFile = parseChunk(source);
+    const targets = createSet([]);
+    const visit = (node) => {
+        const specifier = getRequireSpecifier(node);
+        if (specifier !== null) {
+            const target = resolveRelativeTarget(chunkDir, specifier);
+            if (target !== null && chunkSet.has(target))
+                targets.add(target);
+        }
+        ts.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return targets;
+};
+const buildRequireGraph = (chunks, chunkSet) => {
+    const graph = createMap();
+    for (const chunk of chunks)
+        graph.set(chunk, collectRequireTargets(readFileContent(chunk), getDirname(chunk), chunkSet));
+    return graph;
+};
+/**
+ * Assigns every chunk a strongly-connected-component id via iterative Tarjan, so
+ * a require edge `importer → target` is a cycle exactly when both share an id.
+ *
+ * Iterative (explicit work stack) to stay safe on deep require chains; the graph
+ * is the relative-require graph restricted to chunks under `_dependencies/`.
+ *
+ * @param nodes - All chunk paths, in a stable order.
+ * @param graph - Adjacency from each chunk to the chunks it requires.
+ * @returns Map from chunk path to its SCC id.
+ */
+const computeSccIds = (nodes, graph) => {
+    const index = createMap();
+    const low = createMap();
+    const onStack = createSet([]);
+    const componentOf = createMap();
+    const tarjanStack = [];
+    // why: invariants guarantee every node read below was opened (written) first, so the cast is total.
+    const idxOf = (node) => index.get(node);
+    const lowOf = (node) => low.get(node);
+    // why: the graph holds an entry for every node, so the lookup always resolves.
+    const neighborsOf = (node) => [...graph.get(node)];
+    let counter = 0;
+    let component = 0;
+    const open = (node) => {
+        index.set(node, counter);
+        low.set(node, counter);
+        counter += 1;
+        tarjanStack.push(node);
+        onStack.add(node);
+    };
+    for (const start of nodes) {
+        if (index.has(start))
+            continue;
+        open(start);
+        const work = [{ node: start, neighbors: neighborsOf(start), cursor: 0 }];
+        while (work.length > 0) {
+            const frame = work[work.length - 1];
+            if (frame.cursor < frame.neighbors.length) {
+                const next = frame.neighbors[frame.cursor];
+                frame.cursor += 1;
+                if (!index.has(next)) {
+                    open(next);
+                    work.push({ node: next, neighbors: neighborsOf(next), cursor: 0 });
+                }
+                else if (onStack.has(next))
+                    low.set(frame.node, min(lowOf(frame.node), idxOf(next)));
+                continue;
+            }
+            if (lowOf(frame.node) === idxOf(frame.node)) {
+                for (;;) {
+                    const popped = tarjanStack.pop();
+                    onStack.delete(popped);
+                    componentOf.set(popped, component);
+                    if (popped === frame.node)
+                        break;
+                }
+                component += 1;
+            }
+            work.pop();
+            const parent = work[work.length - 1];
+            if (parent)
+                low.set(parent.node, min(lowOf(parent.node), lowOf(frame.node)));
+        }
+    }
+    return componentOf;
+};
+/**
+ * Collapses whole-module CJS require bindings (`const NS = require('./rel')`) to
+ * destructuring binds across the surviving `_dependencies/` chunks, guarded so it
+ * never destructures across a `require` cycle.
+ *
+ * Builds the relative-require graph over the CJS chunks, finds its
+ * strongly-connected components, and lets each chunk destructure a target only
+ * when the two sit in different components — i.e. the edge is acyclic, so an
+ * eager destructure cannot capture an export before a circular dependency
+ * finished initializing (the exact hazard rollup's namespace-access codegen
+ * avoids). ESM chunks need nothing: their named imports already destructure. A
+ * dynamic `import(`/`require(` anywhere disables the pass for safety, since it
+ * could hide a cycle the static graph cannot see.
+ *
+ * @param depsRoot - Absolute path to the `_dependencies/` directory.
+ * @returns Count of require bindings destructured.
+ *
+ * @example Running the pass after the strip/orphan passes
+ * ```typescript
+ * const { requireBindingsDestructured } = destructureRequiresPass(depsRootOf(context))
+ * ```
+ */
+const destructureRequiresPass = (depsRoot) => {
+    const result = { requireBindingsDestructured: 0 };
+    if (!exists(depsRoot))
+        return result;
+    const chunks = [];
+    walkFiles(depsRoot, (name) => name === CJS_CHUNK, chunks);
+    if (chunks.length === 0)
+        return result;
+    const sources = createMap();
+    for (const chunk of chunks) {
+        const source = readFileContent(chunk);
+        // why: a dynamic specifier could hide a require cycle the static graph misses; bail the whole pass, mirroring the orphan sweep's safety posture.
+        if (hasDynamicSpecifier(source)) {
+            log$3.warn(`dynamic import/require in ${chunk}; skipping require-destructure pass for safety`);
+            return result;
+        }
+        sources.set(chunk, source);
+    }
+    const chunkSet = createSet(chunks);
+    const graph = buildRequireGraph(chunks, chunkSet);
+    const componentOf = computeSccIds(chunks, graph);
+    for (const chunk of chunks) {
+        // why: every chunk was just read into `sources` above, so the lookup always resolves.
+        const source = sources.get(chunk);
+        const myComponent = componentOf.get(chunk);
+        const isSafeTarget = (target) => chunkSet.has(target) && componentOf.get(target) !== myComponent;
+        const rewritten = destructureRequires(source, getDirname(chunk), isSafeTarget);
+        if (!rewritten)
+            continue;
+        writeFileContent(chunk, rewritten.code);
+        result.requireBindingsDestructured += rewritten.rewrittenBindings;
+    }
+    return result;
+};
+
+const propertyName = (element) => {
+    if (ts.isShorthandPropertyAssignment(element))
+        return element.name.text;
+    if (ts.isPropertyAssignment(element) && (ts.isIdentifier(element.name) || ts.isStringLiteralLike(element.name)))
+        return element.name.text;
+    return null;
+};
+// why: only a literal of plain `key: value` / shorthand slots can be safely partitioned; a spread, computed key, method, or accessor makes per-slot removal unsound, so such a literal is left whole (no NamespaceObject yielded).
+const readProperties = (literal) => {
+    const properties = [];
+    for (const element of literal.properties) {
+        const name = propertyName(element);
+        if (name === null)
+            return null;
+        properties.push({ name, element });
+    }
+    return properties;
+};
+const exportedLocalNames = (sourceFile, format) => {
+    const single = createMap();
+    const seen = createSet([]);
+    for (const entry of analyzeChunk(sourceFile, format).exports) {
+        // why: a local published under two names cannot be keyed to one demand set — drop it from the strippable set.
+        if (seen.has(entry.local))
+            single.delete(entry.local);
+        else {
+            seen.add(entry.local);
+            single.set(entry.local, entry.exported);
+        }
+    }
+    return single;
+};
+// context: visits each exported, frozen, plain-slot namespace object in source order. A namespace is a single-declarator top-level `const`/`var` whose initializer is a recognized pure freeze (`Object.freeze`/`seal`/`preventExtensions`, however aliased) of a fresh object literal, and whose local is exported under exactly one name.
+const forEachNamespaceObject = (sourceFile, format, visit) => {
+    const exported = exportedLocalNames(sourceFile, format);
+    const resolution = collectBindingCanonical(sourceFile);
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement) || statement.declarationList.declarations.length !== 1)
+            continue;
+        const decl = statement.declarationList.declarations[0];
+        if (!decl || !ts.isIdentifier(decl.name))
+            continue;
+        const name = decl.name.text;
+        const exportName = exported.get(name);
+        if (exportName === undefined || !decl.initializer || !ts.isCallExpression(decl.initializer))
+            continue;
+        if (!isPureFreezeCall(decl.initializer, resolution))
+            continue;
+        const argument = decl.initializer.arguments[0];
+        if (!argument || !ts.isObjectLiteralExpression(argument))
+            continue;
+        const properties = readProperties(argument);
+        if (properties === null)
+            continue;
+        visit({ exported: exportName, local: name, statement, literal: argument, properties });
+    }
+};
+/**
+ * Analyzes a single chunk for frozen namespace exports and the demand its own
+ * body places on them.
+ *
+ * Returns the namespace exports as node-free data (so the parsed source can be
+ * released) and a self-demand map folding every reference to a namespace's local
+ * binding outside its own declaration and export surface: a static `NS.prop`
+ * read contributes that property, any other use marks the namespace `'all'`.
+ *
+ * @param source - Raw chunk source text.
+ * @param format - Module format selecting the export shape.
+ * @returns The chunk's namespace exports and the demand it self-imposes.
+ *
+ * @example A chunk that exports a frozen namespace it never self-references
+ * ```typescript
+ * analyzeChunkNamespaces('const a = 1;\nconst NS = Object.freeze({ a });\nexport { a, NS };', 'esm')
+ * // => { namespaces: [{ exported: 'NS', properties: ['a'] }], selfDemand: Map {} }
+ * ```
+ */
+const analyzeChunkNamespaces = (source, format) => {
+    const sourceFile = parseChunk(source);
+    const namespaces = [];
+    const localToExport = createMap();
+    const skip = createSet([]);
+    forEachNamespaceObject(sourceFile, format, (object) => {
+        namespaces.push({ exported: object.exported, properties: object.properties.map((property) => property.name) });
+        localToExport.set(object.local, object.exported);
+        skip.add(object.statement);
+    });
+    const selfDemand = createMap();
+    if (namespaces.length === 0)
+        return { namespaces, selfDemand };
+    // why: a namespace's own declaration and its `export { … }` site are not consumer reads — skip them so only genuine internal uses count.
+    for (const entry of analyzeChunk(sourceFile, format).exportSurfaceStatements)
+        skip.add(entry);
+    const visit = (node) => {
+        if (ts.isIdentifier(node)) {
+            const exportName = localToExport.get(node.text);
+            if (exportName !== undefined) {
+                const classification = classifyNamespaceUse(node);
+                if (classification.kind === 'read')
+                    mergeDemand(selfDemand, exportName, createSet([classification.prop]));
+                else if (classification.kind === 'bail')
+                    mergeDemand(selfDemand, exportName, 'all');
+            }
+        }
+        ts.forEachChild(node, visit);
+    };
+    for (const statement of sourceFile.statements)
+        if (!skip.has(statement))
+            visit(statement);
+    return { namespaces, selfDemand };
+};
+/**
+ * Rewrites a chunk's frozen namespace literals to keep only the slots the
+ * consumer graph reads, dropping the rest.
+ *
+ * For every exported frozen namespace, `keepByExport` supplies the property names
+ * to retain (the read set already intersected with the literal's own slots). A
+ * namespace absent from the map, or whose kept set is empty or covers every
+ * slot, is left untouched. Dropping a slot removes the only reference its factory
+ * binding had, so the subsequent dead-export pass collapses the now-dead
+ * factories — this pass only edits the literal.
+ *
+ * @param source - Raw chunk source text.
+ * @param format - Module format selecting the export shape.
+ * @param keepByExport - Per-export set of property names to retain.
+ * @returns The rewritten source and slot-removal count, or `null` when nothing changed.
+ *
+ * @example Keeping a single slot of a two-slot namespace
+ * ```typescript
+ * stripDeadProperties('const a=1;\nconst b=2;\nconst NS=Object.freeze({a,b});\nexport{NS};', 'esm', new Map([['NS', new Set(['a'])]]))
+ * // => literal rewritten to `{ a }`, removedProperties: 1
+ * ```
+ */
+const stripDeadProperties = (source, format, keepByExport) => {
+    const sourceFile = parseChunk(source);
+    const edits = [];
+    let removedProperties = 0;
+    forEachNamespaceObject(sourceFile, format, (object) => {
+        const keep = keepByExport.get(object.exported);
+        if (!keep)
+            return;
+        const survivors = object.properties.filter((property) => keep.has(property.name));
+        // why: never produce an empty `freeze({})` and never rewrite when nothing is dropped.
+        if (survivors.length === 0 || survivors.length === object.properties.length)
+            return;
+        removedProperties += object.properties.length - survivors.length;
+        const rendered = survivors.map((property) => source.slice(property.element.getStart(sourceFile), property.element.getEnd()));
+        edits.push({ start: object.literal.getStart(sourceFile), end: object.literal.getEnd(), text: `{ ${rendered.join(', ')} }` });
+    });
+    if (edits.length === 0)
+        return null;
+    return { code: applyEdits(source, edits), removedProperties };
+};
+
+const FORMAT_FILES = [
+    { format: 'esm', fileName: 'index.esm.js' },
+    { format: 'cjs', fileName: 'index.cjs.js' },
+];
+// why: a dynamic, non-literal `import(`/`require(` anywhere in the consumer graph means a consumer we cannot resolve might read a namespace wholesale — disable property-strip for the format (guaranteed-safe fallback, mirroring the orphan sweep).
+const graphHasDynamicSpecifier = (importers) => importers.some((importer) => hasDynamicSpecifier(readFileContent(importer)));
+const collectChunkNamespaces = (chunks, format) => {
+    const byChunk = createMap();
+    for (const chunk of chunks) {
+        const { namespaces } = analyzeChunkNamespaces(readFileContent(chunk), format);
+        if (namespaces.length > 0)
+            byChunk.set(chunk, namespaces);
+    }
+    return byChunk;
+};
+// why: seed each namespace-bearing chunk's demand with the demand its own body imposes, so an internal read or escape is counted before importers are scanned.
+const seedSelfDemand = (chunks, namespacesByChunk, format) => {
+    const demand = createMap();
+    for (const chunk of chunks) {
+        if (!namespacesByChunk.has(chunk))
+            continue;
+        const { selfDemand } = analyzeChunkNamespaces(readFileContent(chunk), format);
+        demand.set(chunk, selfDemand);
+    }
+    return demand;
+};
+const accumulateImporterDemand = (importers, namespacesByChunk, demand, format) => {
+    for (const importer of importers) {
+        const edges = collectNamespaceUsage(readFileContent(importer), getDirname(importer), format);
+        for (const [target, usage] of edges) {
+            const chunkDemand = demand.get(target);
+            const namespaces = namespacesByChunk.get(target);
+            // why: edges to chunks with no strippable namespace are irrelevant here.
+            if (!chunkDemand || !namespaces)
+                continue;
+            if (usage.bailAll) {
+                for (const namespace of namespaces)
+                    mergeDemand(chunkDemand, namespace.exported, 'all');
+                continue;
+            }
+            for (const [name, propDemand] of usage.perName)
+                mergeDemand(chunkDemand, name, propDemand);
+        }
+    }
+};
+// context: the set of property names to retain for each namespace export of one chunk — only namespaces read at a strict, non-empty subset of their slots, so leaving a fully-unread namespace (dead) to the export pass and a wholesale-consumed one untouched.
+const keepSetsForChunk = (namespaces, chunkDemand) => {
+    const keepByExport = createMap();
+    for (const namespace of namespaces) {
+        const propDemand = chunkDemand.get(namespace.exported);
+        if (propDemand === undefined || propDemand === 'all')
+            continue;
+        const keep = createSet(namespace.properties.filter((property) => propDemand.has(property)));
+        if (keep.size > 0 && keep.size < namespace.properties.length)
+            keepByExport.set(namespace.exported, keep);
+    }
+    return keepByExport;
+};
+const rewriteChunks = (namespacesByChunk, demand, format, result) => {
+    for (const [chunk, namespaces] of namespacesByChunk) {
+        const chunkDemand = demand.get(chunk);
+        if (!chunkDemand)
+            continue;
+        const keepByExport = keepSetsForChunk(namespaces, chunkDemand);
+        if (keepByExport.size === 0)
+            continue;
+        const source = readFileContent(chunk);
+        const stripped = stripDeadProperties(source, format, keepByExport);
+        if (!stripped)
+            continue;
+        writeFileContent(chunk, stripped.code);
+        result.deadPropertiesRemoved += stripped.removedProperties;
+        result.bytesRemoved += Buffer.byteLength(source) - Buffer.byteLength(stripped.code);
+    }
+};
+const processFormat = (context, depsRoot, format, fileName, result) => {
+    const chunks = [];
+    walkFiles(depsRoot, (name) => name === fileName, chunks);
+    if (chunks.length === 0)
+        return;
+    const importers = [...collectEntryFiles(context, depsRoot, [fileName]), ...chunks];
+    if (graphHasDynamicSpecifier(importers))
+        return;
+    const namespacesByChunk = collectChunkNamespaces(chunks, format);
+    if (namespacesByChunk.size === 0)
+        return;
+    const demand = seedSelfDemand(chunks, namespacesByChunk, format);
+    accumulateImporterDemand(importers, namespacesByChunk, demand, format);
+    rewriteChunks(namespacesByChunk, demand, format, result);
+};
+/**
+ * Property-level tree-shaking of kept, live frozen namespace objects: drops the
+ * slots of an exported `freeze({ … })` namespace that no consumer in the whole
+ * graph ever reads, letting the dead-export pass then collapse the now-dead
+ * factory bindings.
+ *
+ * Runs per format (ESM and CJS) over `_dependencies/` chunks. The consumer graph
+ * is the package's entry chunks plus every sibling dependency chunk — a complete
+ * importer set, since per-entry bundling inlines all other first-party code.
+ * Each namespace's demand is the union of its `NS.prop` reads across that graph
+ * (in CJS, a two-level `require(...).NS.prop`); a wholesale consumption (spread,
+ * pass-through, enumeration, dynamic index, re-export, namespace/default import)
+ * or any dynamic specifier in the graph keeps the namespace whole. Only a
+ * namespace read at a strict, non-empty subset of its slots is rewritten. The
+ * caller is expected to re-run the dead-export pass afterwards to reclaim the
+ * orphaned factories.
+ *
+ * @param context - Resolved build context supplying the entry points.
+ * @param depsRoot - Absolute path to the `_dependencies/` directory.
+ * @returns Counts of slots removed and bytes reclaimed.
+ *
+ * @example Running the property strip before the dead-export re-pass
+ * ```typescript
+ * const { deadPropertiesRemoved } = stripDeadPropertiesPass(context, depsRootOf(context))
+ * ```
+ */
+const stripDeadPropertiesPass = (context, depsRoot) => {
+    const result = { deadPropertiesRemoved: 0, bytesRemoved: 0 };
+    if (!exists(depsRoot))
+        return result;
+    for (const { format, fileName } of FORMAT_FILES)
+        processFormat(context, depsRoot, format, fileName, result);
+    return result;
+};
+
+const PRESERVE = /@(?:__PURE__|__NO_SIDE_EFFECTS__|license|preserve|cc_on)|^\s*\/[*/]!|#__PURE__/;
+// why: tokens after which a `/` is the division operator, not a regex opener. After every other token (operators, `(`, `,`, `=`, keywords like `return`/`typeof`, or start of input) a `/` begins a regex, so the scanner must re-lex it as a whole regex literal — otherwise a `//` or `/*` *inside the regex body* (e.g. `/https?:\/\//`, `str.split(/\//g)`) is mis-scanned as comment trivia and the splice corrupts the regex.
+const VALUE_END_TOKENS = createSet([
+    ts.SyntaxKind.Identifier,
+    ts.SyntaxKind.NumericLiteral,
+    ts.SyntaxKind.BigIntLiteral,
+    ts.SyntaxKind.StringLiteral,
+    ts.SyntaxKind.NoSubstitutionTemplateLiteral,
+    ts.SyntaxKind.TemplateTail,
+    ts.SyntaxKind.RegularExpressionLiteral,
+    ts.SyntaxKind.CloseParenToken,
+    ts.SyntaxKind.CloseBracketToken,
+    ts.SyntaxKind.CloseBraceToken,
+    ts.SyntaxKind.PlusPlusToken,
+    ts.SyntaxKind.MinusMinusToken,
+    ts.SyntaxKind.ThisKeyword,
+    ts.SyntaxKind.SuperKeyword,
+    ts.SyntaxKind.TrueKeyword,
+    ts.SyntaxKind.FalseKeyword,
+    ts.SyntaxKind.NullKeyword,
+]);
+/**
+ * Enumerates every comment trivia range in `text` via a `ts.Scanner` over the raw
+ * source. The scanner keeps comment-looking text inside strings, templates, and
+ * (with regex re-lexing) regex literals bound to those tokens, so the ranges it
+ * returns are always genuine comments — never a `//` buried in a string or regex.
+ *
+ * @param text - Raw chunk source to scan.
+ * @returns Every comment trivia range, in ascending source order.
+ */
+const collectComments = (text) => {
+    const scanner = ts.createScanner(ts.ScriptTarget.Latest, /*skipTrivia*/ false, ts.LanguageVariant.Standard, text);
+    const ranges = [];
+    // why: start-of-input is an expression position, so a leading `/` opens a regex.
+    let prevSignificant = ts.SyntaxKind.Unknown;
+    // why: ts.Scanner.scan() does not resume a template literal across its `${...}` substitution on its own — it returns the substitution's closing `}` as a bare CloseBraceToken, so the next backtick is mis-lexed as *opening* a string instead of closing the template. That flips backtick polarity for the rest of the file and exposes `//`/`/*` inside later templates as phantom comments. Track each open substitution's brace depth so the `}` that closes one is re-lexed as the template's continuation (TemplateMiddle when another `${` follows, TemplateTail when the backtick closes); a depth>0 brace is an ordinary block/object brace inside the expression and is left alone.
+    const templateBraceDepths = [];
+    let token = scanner.scan();
+    while (token !== ts.SyntaxKind.EndOfFileToken) {
+        const inSubstitution = templateBraceDepths.length > 0;
+        if ((token === ts.SyntaxKind.SlashToken || token === ts.SyntaxKind.SlashEqualsToken) && !VALUE_END_TOKENS.has(prevSignificant)) {
+            // why: a `/` in expression position is a regex; re-lex the whole literal so its body is never tokenized into stray comments. reScanSlashToken returns the original SlashToken when no valid regex closes on the line, which leaves a true division untouched.
+            token = scanner.reScanSlashToken();
+        }
+        else if (token === ts.SyntaxKind.CloseBraceToken && inSubstitution && templateBraceDepths[templateBraceDepths.length - 1] === 0) {
+            // why: this `}` closes the innermost `${...}`; re-lex it as the template's continuation so the trailing backtick is scanned as template text, not a fresh string opener.
+            token = scanner.reScanTemplateToken(/*isTaggedTemplate*/ false);
+        }
+        if (token === ts.SyntaxKind.SingleLineCommentTrivia || token === ts.SyntaxKind.MultiLineCommentTrivia) {
+            ranges.push({ start: scanner.getTokenStart(), end: scanner.getTextPos() });
+        }
+        else if (token !== ts.SyntaxKind.WhitespaceTrivia && token !== ts.SyntaxKind.NewLineTrivia) {
+            // why: comments and whitespace don't change whether the next `/` is division or regex; only real tokens do.
+            prevSignificant = token;
+        }
+        // why: maintain the substitution-depth stack after re-lexing so each token's effect (open a substitution, descend/ascend a nested brace, or close the template) is counted once.
+        if (token === ts.SyntaxKind.TemplateHead)
+            templateBraceDepths.push(0);
+        else if (token === ts.SyntaxKind.TemplateTail)
+            templateBraceDepths.pop();
+        else if (inSubstitution && token === ts.SyntaxKind.OpenBraceToken)
+            templateBraceDepths[templateBraceDepths.length - 1]++;
+        else if (inSubstitution && token === ts.SyntaxKind.CloseBraceToken)
+            templateBraceDepths[templateBraceDepths.length - 1]--;
+        token = scanner.scan();
+    }
+    return ranges;
+};
+// why: include `\r` so a CRLF whole-line comment (trailing `\r` before the `\n`) still takes the line-collapse path. Rollup emits LF today, but a CRLF chunk would otherwise leave the `\r\n` residue behind.
+const isBlankSlice = (text, from, to) => /^[ \t\r]*$/.test(text.slice(from, to));
+const lineStartOf = (text, pos) => text.lastIndexOf('\n', pos - 1) + 1;
+const nextNewline = (text, pos) => {
+    const nl = text.indexOf('\n', pos);
+    return nl === -1 ? text.length : nl;
+};
+/**
+ * Expands a bare comment range to the removal range actually spliced out.
+ *
+ * A comment that occupies a whole line (only whitespace before it on the line and
+ * only whitespace after it up to the newline) is removed line-and-all, then any
+ * immediately following blank lines are swallowed so contiguous JSDoc/banner
+ * removals collapse without leaving blank-line residue. An inline comment is
+ * removed verbatim. Blank-line swallowing is template-safe by construction:
+ * comments only exist in code context, so the lines adjacent to a removed comment
+ * are never inside a string or template literal.
+ *
+ * @param text - Raw chunk source the comment was found in.
+ * @param comment - The bare comment range to expand.
+ * @returns The offset range to splice out for this comment.
+ */
+const removalRange = (text, comment) => {
+    const lineStart = lineStartOf(text, comment.start);
+    const eol = nextNewline(text, comment.end);
+    const wholeLine = isBlankSlice(text, lineStart, comment.start) && isBlankSlice(text, comment.end, eol);
+    if (!wholeLine)
+        return comment;
+    let to = eol < text.length ? eol + 1 : eol;
+    while (to < text.length) {
+        const nl = nextNewline(text, to);
+        if (!isBlankSlice(text, to, nl))
+            break;
+        to = nl < text.length ? nl + 1 : nl;
+    }
+    return { start: lineStart, end: to };
+};
+
+const stripComments = (source) => {
+    const removable = collectComments(source).filter((range) => !PRESERVE.test(source.slice(range.start, range.end)));
+    if (removable.length === 0)
+        return null;
+    const ranges = removable.map((comment) => removalRange(source, comment));
+    // why: splice from the back so each earlier (smaller) offset stays valid; the ranges are disjoint and ascending, so descending removal never disturbs a not-yet-applied offset.
+    let out = source;
+    for (let i = ranges.length - 1; i >= 0; i--)
+        out = out.slice(0, ranges[i].start) + out.slice(ranges[i].end);
+    return out;
+};
+
+const stripCommentsPass = (depsRoot) => {
+    const result = { commentBytesRemoved: 0 };
+    if (!exists(depsRoot))
+        return result;
+    const chunks = [];
+    walkFiles(depsRoot, (name) => name === 'index.esm.js' || name === 'index.cjs.js', chunks);
+    for (const chunk of chunks) {
+        const source = readFileContent(chunk);
+        const stripped = stripComments(source);
+        if (stripped === null)
+            continue;
+        writeFileContent(chunk, stripped);
+        result.commentBytesRemoved += Buffer.byteLength(source) - Buffer.byteLength(stripped);
+    }
+    return result;
+};
+
+const log$2 = logger.channel('builder:bundle:dependencies:prune');
+
+const pruneDependencies = (context, monitor) => {
+    const depsRoot = depsRootOf(context);
+    const orphans = pruneOrphanChunks(context, depsRoot);
+    monitor?.check('bundle:dependencies:prune:orphans:end');
+    const deadExports = stripDeadExportsPass(context, depsRoot);
+    monitor?.check('bundle:dependencies:prune:dead-exports:end');
+    const properties = stripDeadPropertiesPass(context, depsRoot);
+    monitor?.check('bundle:dependencies:prune:property-strip:end');
+    // why: dropping a namespace slot orphans the factory binding it held alive; a second export strip collapses those (and re-narrows the imports they pulled).
+    const cascade = properties.deadPropertiesRemoved > 0 ? stripDeadExportsPass(context, depsRoot) : { deadExportsRemoved: 0, bytesRemoved: 0 };
+    // why: a chunk whose last importing symbol was just stripped is now an orphan; reclaim it (and any d.ts left behind).
+    const resweep = pruneOrphanChunks(context, depsRoot);
+    // why: collapse whole-module CJS require bindings to destructures once the chunk surfaces are final; runs among the AST passes (before the comment strip) since it rewrites member-access spans.
+    const destructured = destructureRequiresPass(depsRoot);
+    monitor?.check('bundle:dependencies:prune:destructure-requires:end');
+    
+    const comments = stripCommentsPass(depsRoot);
+    monitor?.check('bundle:dependencies:prune:comment-strip:end');
+    const report = {
+        orphanFilesRemoved: orphans.orphanFilesRemoved + resweep.orphanFilesRemoved,
+        deadExportsRemoved: deadExports.deadExportsRemoved + cascade.deadExportsRemoved,
+        deadPropertiesRemoved: properties.deadPropertiesRemoved,
+        requireBindingsDestructured: destructured.requireBindingsDestructured,
+        commentBytesRemoved: comments.commentBytesRemoved,
+        bytesRemoved: orphans.bytesRemoved +
+            deadExports.bytesRemoved +
+            properties.bytesRemoved +
+            cascade.bytesRemoved +
+            resweep.bytesRemoved +
+            comments.commentBytesRemoved,
+    };
+    if (report.orphanFilesRemoved > 0 ||
+        report.deadExportsRemoved > 0 ||
+        report.deadPropertiesRemoved > 0 ||
+        report.requireBindingsDestructured > 0 ||
+        report.commentBytesRemoved > 0) {
+        log$2.info(`pruned ${report.orphanFilesRemoved} orphan dependency file(s), ${report.deadExportsRemoved} dead export(s), and ${report.deadPropertiesRemoved} dead namespace slot(s), destructured ${report.requireBindingsDestructured} require binding(s), stripped ${report.commentBytesRemoved} comment byte(s), reclaimed ${report.bytesRemoved} byte(s)`);
+    }
+    return report;
+};
+
+const readPkg = (packageJsonPath) => (exists$1(packageJsonPath) ? readJsonFile(packageJsonPath) : {});
+/**
+ * Resolves the external package list for a single bundle.
+ *
+ * The output combines:
+ * - top-level `dependencies` from the project's `package.json`
+ * - `peerDependencies` (always external regardless of `bundleWorkspaceDeps`)
+ * - the caller-supplied `additional` list
+ *
+ * When `bundleWorkspaceDeps` is `true` and a workspace predicate is supplied, packages
+ * matching the predicate are stripped from `dependencies` and `additional` so they get
+ * inlined by the bundler. Peer dependencies are always preserved.
+ *
+ * @param options - Inputs controlling the resolution.
+ * @returns Sorted, de-duplicated list of external package names.
+ *
+ * @example Resolving externals while inlining workspace deps
+ * ```typescript
+ * const external = resolveExternals({
+ *   packageJsonPath: '/abs/libs/foo/package.json',
+ *   isWorkspacePackage: (n) => n.startsWith('@hyperfrontend/'),
+ *   bundleWorkspaceDeps: true,
+ * })
+ * ```
+ */
+const resolveExternals = (options) => {
+    const pkg = readPkg(options.packageJsonPath);
+    const deps = keys(pkg.dependencies ?? {});
+    const peerDeps = keys(pkg.peerDependencies ?? {});
+    const additional = options.additional ?? [];
+    const bundledSet = createSet(options.bundledDeps ?? []);
+    const workspaceBundledSet = createSet(options.workspaceBundledDepNames ?? []);
+    const inlineWorkspace = options.bundleWorkspaceDeps === true && options.isWorkspacePackage !== undefined;
+    const filterWorkspace = (names) => inlineWorkspace ? names.filter((n) => !options.isWorkspacePackage(n)) : names;
+    const filterBundled = (names) => (bundledSet.size === 0 ? names : names.filter((n) => !bundledSet.has(n)));
+    const filterWorkspaceBundled = (names) => workspaceBundledSet.size === 0 ? names : names.filter((n) => !workspaceBundledSet.has(n));
+    return from(createSet([
+        ...filterWorkspaceBundled(filterBundled(filterWorkspace(deps))),
+        ...filterWorkspaceBundled(filterBundled(peerDeps)),
+        ...filterWorkspaceBundled(filterBundled(filterWorkspace(additional))),
+    ]));
+};
+
+const computeEntryOutputDir = (entry, context) => entry.srcPath ? join$3(context.outputPath, entry.srcPath) : context.outputPath;
+const computeBundleOutputDir = (bundleSubDir, context) => join$3(context.outputPath, bundleSubDir ?? 'bundle');
+/**
+ * Builds the worker descriptor for the ESM output of a single entry point.
+ *
+ * The returned descriptor is fully serializable (no functions), ready to be
+ * passed to {@link dispatchRollupWorker}.
+ *
+ * @param entry - Entry point to compile.
+ * @param config - ESM-format configuration.
+ * @param context - Resolved build context.
+ * @param reportPath - Absolute path the worker will write its JSON report to.
+ * @returns Descriptor ready to be JSON-serialized for the worker.
+ *
+ * @example Producing the descriptor for the root entry
+ * ```typescript
+ * const descriptor = toEsmBuildDescriptor(entry, esmConfig, context, '/tmp/report.json')
+ * ```
+ */
+const toEsmBuildDescriptor = (entry, config, context, reportPath) => {
+    const outputDir = computeEntryOutputDir(entry, context);
+    const sourcemap = config.sourcemap ?? false;
+    const bundleWorkspaceDeps = config.bundleWorkspaceDeps ?? true;
+    const bundleAllRequested = Boolean(config.bundleAllDeps);
+    const bundledDeps = bundleAllRequested ? context.bundledDeps : [];
+    const workspaceRoutes = bundleAllRequested ? buildWorkspaceRoutes(context.workspaceBundledDeps) : [];
+    const useExternalizePlugin = bundledDeps.length > 0 || workspaceRoutes.length > 0;
+    const external = resolveExternals({
+        packageJsonPath: join$3(context.projectRoot, 'package.json'),
+        additional: [...context.external, ...(config.external ?? [])],
+        isWorkspacePackage: context.isWorkspacePackage,
+        bundleWorkspaceDeps,
+        bundledDeps,
+        workspaceBundledDepNames: workspaceRoutes.map((r) => r.packageName),
+    });
+    return {
+        format: 'esm',
+        inputFile: entry.inputFile,
+        outputDir,
+        external,
+        sourcemap,
+        bundledDepsPlugin: useExternalizePlugin ? { deps: bundledDeps, depsRoot: depsRootOf(context) } : null,
+        workspaceRoutes,
+        tsConfigPath: context.tsConfigPath,
+        projectRoot: context.projectRoot,
+        workspaceRoot: context.workspaceRoot,
+        bundleWorkspaceDeps,
+        bundle: null,
+        bin: null,
+        reportPath,
+    };
+};
+/**
+ * Builds the worker descriptor for the CommonJS output of a single entry point.
+ *
+ * @param entry - Entry point to compile.
+ * @param config - CJS-format configuration.
+ * @param context - Resolved build context.
+ * @param reportPath - Absolute path the worker will write its JSON report to.
+ * @returns Descriptor ready to be JSON-serialized for the worker.
+ *
+ * @example Producing the descriptor for the root entry
+ * ```typescript
+ * const descriptor = toCjsBuildDescriptor(entry, cjsConfig, context, '/tmp/report.json')
+ * ```
+ */
+const toCjsBuildDescriptor = (entry, config, context, reportPath) => {
+    const outputDir = computeEntryOutputDir(entry, context);
+    const sourcemap = config.sourcemap ?? false;
+    const bundleWorkspaceDeps = config.bundleWorkspaceDeps ?? true;
+    const bundleAllRequested = Boolean(config.bundleAllDeps);
+    const bundledDeps = bundleAllRequested ? context.bundledDeps : [];
+    const workspaceRoutes = bundleAllRequested ? buildWorkspaceRoutes(context.workspaceBundledDeps) : [];
+    const useExternalizePlugin = bundledDeps.length > 0 || workspaceRoutes.length > 0;
+    const external = resolveExternals({
+        packageJsonPath: join$3(context.projectRoot, 'package.json'),
+        additional: [...context.external, ...(config.external ?? [])],
+        isWorkspacePackage: context.isWorkspacePackage,
+        bundleWorkspaceDeps,
+        bundledDeps,
+        workspaceBundledDepNames: workspaceRoutes.map((r) => r.packageName),
+    });
+    return {
+        format: 'cjs',
+        inputFile: entry.inputFile,
+        outputDir,
+        external,
+        sourcemap,
+        bundledDepsPlugin: useExternalizePlugin ? { deps: bundledDeps, depsRoot: depsRootOf(context) } : null,
+        workspaceRoutes,
+        tsConfigPath: context.tsConfigPath,
+        projectRoot: context.projectRoot,
+        workspaceRoot: context.workspaceRoot,
+        bundleWorkspaceDeps,
+        bundle: null,
+        bin: null,
+        reportPath,
+    };
+};
+/**
+ * Builds the worker descriptor for an IIFE bundle of a single entry point.
+ *
+ * Validates the externals/globals pairing eagerly, throwing before the
+ * descriptor is returned.
+ *
+ * @param entry - Entry point to bundle.
+ * @param config - IIFE-format configuration.
+ * @param context - Resolved build context.
+ * @param reportPath - Absolute path the worker will write its JSON report to.
+ * @returns Descriptor ready to be JSON-serialized for the worker.
+ * @throws {Error} When `config.external` is non-empty but `config.globals` is missing entries.
+ *
+ * @example Producing the descriptor for an IIFE bundle
+ * ```typescript
+ * const descriptor = toIifeBuildDescriptor(entry, iifeConfig, context, '/tmp/report.json')
+ * ```
+ */
+const toIifeBuildDescriptor = (entry, config, context, reportPath) => {
+    validateExternalsConfig(config.external, config.globals);
+    const outputDir = computeBundleOutputDir(config.output, context);
+    const sourcemap = config.sourcemap ?? false;
+    const minify = config.minify ?? true;
+    return {
+        format: 'iife',
+        inputFile: entry.inputFile,
+        outputDir,
+        external: config.external ?? [],
+        sourcemap,
+        bundledDepsPlugin: null,
+        workspaceRoutes: [],
+        tsConfigPath: context.tsConfigPath,
+        projectRoot: context.projectRoot,
+        workspaceRoot: context.workspaceRoot,
+        bundleWorkspaceDeps: false,
+        bundle: { globalName: config.globalName, minify, globals: config.globals },
+        bin: null,
+        reportPath,
+    };
+};
+/**
+ * Builds the worker descriptor for a UMD bundle of a single entry point.
+ *
+ * Validates the externals/globals pairing eagerly, throwing before the
+ * descriptor is returned.
+ *
+ * @param entry - Entry point to bundle.
+ * @param config - UMD-format configuration.
+ * @param context - Resolved build context.
+ * @param reportPath - Absolute path the worker will write its JSON report to.
+ * @returns Descriptor ready to be JSON-serialized for the worker.
+ * @throws {Error} When `config.external` is non-empty but `config.globals` is missing entries.
+ *
+ * @example Producing the descriptor for a UMD bundle
+ * ```typescript
+ * const descriptor = toUmdBuildDescriptor(entry, umdConfig, context, '/tmp/report.json')
+ * ```
+ */
+const toUmdBuildDescriptor = (entry, config, context, reportPath) => {
+    validateExternalsConfig(config.external, config.globals);
+    const outputDir = computeBundleOutputDir(config.output, context);
+    const sourcemap = config.sourcemap ?? false;
+    const minify = config.minify ?? true;
+    return {
+        format: 'umd',
+        inputFile: entry.inputFile,
+        outputDir,
+        external: config.external ?? [],
+        sourcemap,
+        bundledDepsPlugin: null,
+        workspaceRoutes: [],
+        tsConfigPath: context.tsConfigPath,
+        projectRoot: context.projectRoot,
+        workspaceRoot: context.workspaceRoot,
+        bundleWorkspaceDeps: false,
+        bundle: { globalName: config.globalName, minify, globals: config.globals, amdId: config.amdId },
+        bin: null,
+        reportPath,
+    };
+};
+
+const log$1 = logger.channel('builder:bundle:rollup:dispatch');
+const REPORT_DIR_PREFIX = 'hf-builder-rollup-';
+const SWC_NODE_REGISTER = '@swc-node/register';
+const swcNodeAvailable = (workspaceRoot) => existsSync(join$2(workspaceRoot, 'node_modules', '@swc-node', 'register', 'index.js'));
+/**
+ * Default worker-path resolution: prefers the built-and-published artifact, falls
+ * back to the workspace dist path, and finally to the in-source TypeScript file
+ * via `@swc-node/register` (bootstrap case where builder is building itself for
+ * the first time and the dist worker doesn't exist yet).
+ *
+ * Looks at, in order:
+ * 1. `<workspaceRoot>/dist/libs/builder/bundle/rollup/worker/index.cjs.js`
+ * 2. `<workspaceRoot>/node_modules/@hyperfrontend/builder/bundle/rollup/worker/index.cjs.js`
+ * 3. `<workspaceRoot>/libs/builder/src/bundle/rollup/worker/index.ts` (with `--require \@swc-node/register`)
+ *
+ * @param workspaceRoot - Absolute workspace root.
+ * @returns Worker invocation descriptor, or `undefined` if no candidate exists.
+ *
+ * @example Locating the worker for an in-workspace consumer
+ * ```typescript
+ * const invocation = resolveDefaultRollupWorkerPath('/abs/repo')
+ * if (!invocation) throw new Error('builder rollup worker artifact not found')
+ * ```
+ */
+const resolveDefaultRollupWorkerPath = (workspaceRoot) => {
+    const distCandidates = [
+        join$2(workspaceRoot, 'dist', 'libs', 'builder', 'bundle', 'rollup', 'worker', 'index.cjs.js'),
+        join$2(workspaceRoot, 'node_modules', '@hyperfrontend', 'builder', 'bundle', 'rollup', 'worker', 'index.cjs.js'),
+    ];
+    for (const path of distCandidates) {
+        if (existsSync(path))
+            return { path, execArgv: [] };
+    }
+    const sourcePath = join$2(workspaceRoot, 'libs', 'builder', 'src', 'bundle', 'rollup', 'worker', 'index.ts');
+    if (existsSync(sourcePath) && swcNodeAvailable(workspaceRoot)) {
+        return { path: sourcePath, execArgv: ['--require', SWC_NODE_REGISTER] };
+    }
+    return undefined;
+};
+const createReportDir = () => mkdtempSync(join$2(tmpdir(), REPORT_DIR_PREFIX));
+const reportPathFor = (reportDir, descriptor) => {
+    const safeLabel = descriptor.inputFile.replace(/[^a-zA-Z0-9_-]+/g, '_');
+    return join$2(reportDir, `${descriptor.format}-${safeLabel}.json`);
+};
+const runOne = (descriptor, options, label) => createPromise((resolve, reject) => {
+    const execPath = options.execPath ?? process.execPath;
+    const argv = [...(options.execArgv ?? []), options.workerPath, stringify(descriptor)];
+    const child = spawn(execPath, argv, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let capturedStderr = '';
+    child.stdout?.on('data', (chunk) => {
+        process.stdout.write(chunk);
+    });
+    child.stderr?.on('data', (chunk) => {
+        const text = typeof chunk === 'string' ? chunk : chunk.toString();
+        capturedStderr += text;
+        process.stderr.write(text);
+    });
+    child.on('error', (error) => {
+        reject(createError(`rollup worker for ${label} failed to spawn: ${error.message}`));
+    });
+    child.on('exit', (code) => {
+        if (code !== 0) {
+            const tail = capturedStderr.trim().split('\n').slice(-10).join('\n');
+            reject(createError(`rollup worker for ${label} exited with code ${code}\n${tail}`));
+            return;
+        }
+        resolve();
+    });
+});
+const readReport = (reportPath, label) => {
+    if (!existsSync(reportPath)) {
+        throw createError(`rollup worker for ${label} did not write a report at ${reportPath}`);
+    }
+    const data = parse(readFileSync(reportPath, 'utf8'));
+    return data;
+};
+/**
+ * Forks a single rollup worker for the supplied descriptor and waits for it
+ * to exit. The caller-provided descriptor's `reportPath` is overwritten with
+ * a temp-dir path created by this function.
+ *
+ * Each worker writes a JSON report at the temp path; this function reads it
+ * after the child exits and returns the per-job statistics. If the worker
+ * exits non-zero or fails to produce a report, the function throws with a
+ * label-rich message.
+ *
+ * The temp report directory is cleaned up before returning, regardless of
+ * success or failure.
+ *
+ * @param descriptor - Build descriptor to dispatch.
+ * @param options - Worker path + optional memory monitor.
+ * @returns Worker report (output size + memory + duration) for the dispatched job.
+ *
+ * @example Dispatching a single ESM build
+ * ```typescript
+ * const report = await dispatchRollupWorker(descriptor, { workerPath: '/abs/dist/.../worker.cjs.js' })
+ * ```
+ */
+const dispatchRollupWorker = async (descriptor, options) => {
+    const reportDir = createReportDir();
+    const label = options.label ?? `${descriptor.format}:${descriptor.inputFile}`;
+    const reportPath = reportPathFor(reportDir, descriptor);
+    const job = { ...descriptor, reportPath };
+    try {
+        options.monitor?.check(`bundle:rollup:dispatch:${label}:start`);
+        log$1.info(`rollup dispatch: ${label}`);
+        await runOne(job, options, label);
+        const report = readReport(reportPath, label);
+        log$1.debug(`rollup dispatch done: ${label} size=${report.outputSize}B heap=${report.endHeapMB.toFixed(1)}MB rss=${report.endRssMB.toFixed(1)}MB t=${report.durationMs}ms`);
+        options.monitor?.check(`bundle:rollup:dispatch:${label}:end`);
+        return report;
+    }
+    finally {
+        rmSync(reportDir, { recursive: true, force: true });
+    }
+};
+
+const log = logger.channel('builder:bundle');
+const toArray = (value) => (value === undefined ? [] : isArray(value) ? value : [value]);
+const collectFormatsRequestingPrePass = (config) => {
+    const formats = createSet([]);
+    for (const c of toArray(config.esm))
+        if (c.bundleAllDeps)
+            formats.add('esm');
+    for (const c of toArray(config.cjs))
+        if (c.bundleAllDeps)
+            formats.add('cjs');
+    return from(formats);
+};
+const buildJsPrePassJobs = (deps, formats, context) => {
+    const jobs = [];
+    const depsRoot = depsRootOf(context);
+    const workspacePrefixDeps = collectWorkspacePrefixDeps(context);
+    const workspaceExactSpecifiers = collectWorkspaceExactSpecifiers(context);
+    const workspaceRoutes = buildWorkspaceRoutes(context.workspaceBundledDeps);
+    for (const dep of deps) {
+        const entry = resolveDepEntry({ dep, projectRoot: context.projectRoot, workspaceRoot: context.workspaceRoot, kind: 'js' });
+        const otherNpmDeps = deps.filter((d) => d !== dep);
+        for (const format of formats) {
+            jobs.push({
+                kind: 'js',
+                dep,
+                inputPath: entry,
+                format,
+                outputPath: join$2(depsRoot, dep, chunkFileName(format)),
+                otherDeps: [...otherNpmDeps, ...workspacePrefixDeps],
+                otherWorkspaceSpecifiers: workspaceExactSpecifiers,
+                npmDeps: otherNpmDeps,
+                workspaceRoutes,
+                depsRoot,
+            });
+        }
+    }
+    return jobs;
+};
+const workspaceOutputFile = (entry, format) => {
+    const fileName = chunkFileName(format);
+    return entry.subPath ? `${entry.specifier}/${fileName}` : `${entry.packageName}/${fileName}`;
+};
+const filterRouteEntries = (entry, all) => all.filter((other) => (entry.policy === 'sub-path' ? other.specifier !== entry.specifier : other.packageName !== entry.packageName));
+const buildWorkspaceJsPrePassJobs = (npmDeps, formats, context) => {
+    if (context.workspaceBundledDeps.length === 0)
+        return [];
+    const jobs = [];
+    const depsRoot = depsRootOf(context);
+    const wholeSurface = collectWorkspacePrefixDeps(context);
+    const subPathSpecifiers = collectWorkspaceExactSpecifiers(context);
+    for (const entry of context.workspaceBundledDeps) {
+        const otherWorkspacePackages = wholeSurface.filter((name) => name !== entry.packageName || entry.policy === 'sub-path');
+        const otherSubPathSpecifiers = subPathSpecifiers.filter((spec) => spec !== entry.specifier);
+        const workspaceRoutes = buildWorkspaceRoutes(filterRouteEntries(entry, context.workspaceBundledDeps));
+        for (const format of formats) {
+            jobs.push({
+                kind: 'workspace-js',
+                dep: entry.specifier,
+                inputPath: entry.inputPath,
+                format,
+                outputPath: join$2(depsRoot, workspaceOutputFile(entry, format)),
+                otherDeps: [...npmDeps, ...otherWorkspacePackages],
+                otherWorkspaceSpecifiers: otherSubPathSpecifiers,
+                tsConfigPath: entry.tsConfigPath,
+                workspaceRoot: context.workspaceRoot,
+                npmDeps,
+                workspaceRoutes,
+                depsRoot,
+            });
+        }
+    }
+    return jobs;
+};
+const resolvePrePassWorkerOrThrow = (workspaceRoot) => {
+    const invocation = resolveDefaultWorkerPath(workspaceRoot);
+    if (!invocation) {
+        throw createError('bundleAllDeps is enabled but the pre-pass worker could not be resolved. Build @hyperfrontend/builder once with bundleAllDeps disabled, or ensure @swc-node/register is installed for source-mode bootstrap.');
+    }
+    return invocation;
+};
+const resolveRollupWorkerOrThrow = (workspaceRoot) => {
+    const invocation = resolveDefaultRollupWorkerPath(workspaceRoot);
+    if (!invocation) {
+        throw createError('rollup worker could not be resolved. Build @hyperfrontend/builder at least once before invoking the bundle phase, or ensure @swc-node/register is installed for source-mode bootstrap.');
+    }
+    return invocation;
+};
+const createLazyDispatchResolver = (workspaceRoot) => {
+    let cached = null;
+    return () => {
+        if (!cached) {
+            const invocation = resolveRollupWorkerOrThrow(workspaceRoot);
+            cached = { workerPath: invocation.path, execArgv: invocation.execArgv };
+        }
+        return cached;
+    };
+};
+const dispatch = async (descriptor, label, options) => {
+    await dispatchRollupWorker(descriptor, {
+        workerPath: options.workerPath,
+        execArgv: options.execArgv,
+        label,
+    });
+};
+const runEsmFormats = async (config, context, outputs, resolveDispatch, monitor) => {
+    for (const esmConfig of toArray(config.esm)) {
+        const entries = resolveEntries(esmConfig, context.entryPointDiscovery.entryPoints);
+        for (const [i, entry] of entries.entries()) {
+            const label = `esm:${i}/${entries.length}:${entry.exportPath}`;
+            monitor?.check(`bundle:${label}:start`);
+            const descriptor = toEsmBuildDescriptor(entry, esmConfig, context, '');
+            await dispatch(descriptor, label, resolveDispatch());
+            monitor?.check(`bundle:${label}:end`);
+        }
+        outputs.esm.push(...entries);
+    }
+};
+const runCjsFormats = async (config, context, outputs, resolveDispatch, monitor) => {
+    for (const cjsConfig of toArray(config.cjs)) {
+        const entries = resolveEntries(cjsConfig, context.entryPointDiscovery.entryPoints);
+        for (const [i, entry] of entries.entries()) {
+            const label = `cjs:${i}/${entries.length}:${entry.exportPath}`;
+            monitor?.check(`bundle:${label}:start`);
+            const descriptor = toCjsBuildDescriptor(entry, cjsConfig, context, '');
+            await dispatch(descriptor, label, resolveDispatch());
+            monitor?.check(`bundle:${label}:end`);
+        }
+        outputs.cjs.push(...entries);
+    }
+};
+const runIifeFormats = async (config, context, outputs, resolveDispatch, monitor) => {
+    for (const iifeConfig of toArray(config.iife)) {
+        const entries = resolveEntries(iifeConfig, context.entryPointDiscovery.entryPoints);
+        if (entries.length === 0)
+            continue;
+        ensureDir(join$2(context.outputPath, iifeConfig.output ?? 'bundle'));
+        for (const [i, entry] of entries.entries()) {
+            const label = `iife:${i}/${entries.length}:${entry.exportPath}`;
+            monitor?.check(`bundle:${label}:start`);
+            const descriptor = toIifeBuildDescriptor(entry, iifeConfig, context, '');
+            await dispatch(descriptor, label, resolveDispatch());
+            monitor?.check(`bundle:${label}:end`);
+        }
+        outputs.iife.push({ config: iifeConfig, entries });
+    }
+};
+const runUmdFormats = async (config, context, outputs, resolveDispatch, monitor) => {
+    for (const umdConfig of toArray(config.umd)) {
+        const entries = resolveEntries(umdConfig, context.entryPointDiscovery.entryPoints);
+        if (entries.length === 0)
+            continue;
+        ensureDir(join$2(context.outputPath, umdConfig.output ?? 'bundle'));
+        for (const [i, entry] of entries.entries()) {
+            const label = `umd:${i}/${entries.length}:${entry.exportPath}`;
+            monitor?.check(`bundle:${label}:start`);
+            const descriptor = toUmdBuildDescriptor(entry, umdConfig, context, '');
+            await dispatch(descriptor, label, resolveDispatch());
+            monitor?.check(`bundle:${label}:end`);
+        }
+        outputs.umd.push({ config: umdConfig, entries });
+    }
+};
+/**
+ * Runs the entire bundle phase: ESM, CJS, IIFE, UMD outputs followed by declaration emission.
+ *
+ * Iterates the format-specific configurations in `config`, resolves the matching
+ * entry points for each format, and bundles every one. After all bundles are
+ * written, emits `.d.ts` declarations for the project exactly once.
+ *
+ * @param context - Resolved build context.
+ * @param config - Top-level builder configuration. Only the format and `tsConfig`
+ * fields are consulted by this phase.
+ * @param monitor - Optional memory monitor; when provided, peak heap inside the
+ * bundle phase is sampled at each format and declaration step.
+ * @returns Aggregated outputs grouped by format.
+ *
+ * @example Driving the bundle phase from a custom orchestrator
+ * ```typescript
+ * const formatOutputs = await runBundlePhase(context, config)
+ * ```
+ */
+const runBundlePhase = async (context, config, monitor) => {
+    const outputs = { esm: [], cjs: [], iife: [], umd: [] };
+    const requestedPrePassFormats = collectFormatsRequestingPrePass(config);
+    if (requestedPrePassFormats.length > 0 && (context.bundledDeps.length > 0 || context.workspaceBundledDeps.length > 0)) {
+        const invocation = resolvePrePassWorkerOrThrow(context.workspaceRoot);
+        const npmJobs = buildJsPrePassJobs(context.bundledDeps, requestedPrePassFormats, context);
+        const workspaceJobs = buildWorkspaceJsPrePassJobs(context.bundledDeps, requestedPrePassFormats, context);
+        const jobs = [...npmJobs, ...workspaceJobs];
+        log.info(`bundle dependencies pre-pass: ${context.bundledDeps.length} npm + ${context.workspaceBundledDeps.length} workspace × ${requestedPrePassFormats.length} formats = ${jobs.length} jobs`);
+        monitor?.check('bundle:dependencies:prepass:start');
+        await runPrePass(jobs, { workerPath: invocation.path, execArgv: invocation.execArgv, monitor });
+        monitor?.check('bundle:dependencies:prepass:end');
+    }
+    const resolveDispatch = createLazyDispatchResolver(context.workspaceRoot);
+    await runEsmFormats(config, context, outputs, resolveDispatch, monitor);
+    await recover();
+    monitor?.check('bundle:esm:end:post-recover');
+    await runCjsFormats(config, context, outputs, resolveDispatch, monitor);
+    await recover();
+    monitor?.check('bundle:cjs:end:post-recover');
+    await runIifeFormats(config, context, outputs, resolveDispatch, monitor);
+    await runUmdFormats(config, context, outputs, resolveDispatch, monitor);
+    await recover();
+    monitor?.check('bundle:declarations:start');
+    await generateDeclarations(context);
+    monitor?.check('bundle:declarations:end');
+    if (context.bundledDeps.length > 0 || context.workspaceBundledDeps.length > 0) {
+        await runDtsPrePass(context, monitor);
+        await runDtsPerEntry(context, monitor);
+    }
+    pruneOrphanDeclarations(context);
+    monitor?.check('bundle:declarations:prune-orphans:end');
+    if (context.bundledDeps.length > 0 || context.workspaceBundledDeps.length > 0) {
+        pruneDependencies(context, monitor);
+        monitor?.check('bundle:dependencies:prune:end');
+    }
+    // why: dedup runs after prune so the lifted `_shared/` files are still present when `finalizeFilesAllowlist` reflects the published output tree.
+    if (config.dedupeSharedInternals !== false) {
+        hoistSharedFirstParty(context, monitor);
+        monitor?.check('bundle:dedupe:shared-first-party:end');
+    }
+    // why: runs last (after the final file-producing pass) so no later pass re-creates a file under a removed directory; sweeps the per-source dirs left empty by the orphan-d.ts prune across the whole package, not just `_dependencies/`. Guarded for the degenerate case where no format produced an output tree.
+    if (exists(context.outputPath)) {
+        const emptyDirsRemoved = removeEmptyDirs(context.outputPath);
+        if (emptyDirsRemoved > 0)
+            log.info(`removed ${emptyDirsRemoved} empty director${emptyDirsRemoved === 1 ? 'y' : 'ies'}`);
+    }
+    monitor?.check('bundle:empty-dirs:end');
+    return outputs;
+};
+
+export { runBundlePhase };