@hyperfrontend/builder 0.1.0

package/bundle/dependencies/worker/index.d.ts

@@ -0,0 +1,102 @@
+import { SiblingEntry } from '../../declarations';
+import { WorkspaceBundledDepRoute } from '..';
+
+/**
+ * Pre-pass kinds. `js` and `dts` cover npm bundled deps with pre-built JS and
+ * `.d.ts` entries; `workspace-js` and `workspace-dts` cover workspace
+ * `@hyperfrontend/*` deps whose entries are TypeScript source and require
+ * type-aware transformation against the workspace tsconfig.
+ */
+type PrePassWorkerJobKind = 'js' | 'dts' | 'workspace-js' | 'workspace-dts';
+/**
+ * Job spec consumed by the pre-pass worker via `process.argv[2]`.
+ *
+ * Each invocation produces exactly one rollup output and one JSON report at
+ * `reportPath` so the parent orchestrator can collect per-job statistics.
+ */
+interface PrePassWorkerJob {
+    /**
+     * Pre-pass kind. `js` and `dts` run the npm-dep pipeline; `workspace-js` and
+     * `workspace-dts` add `@rollup/plugin-typescript` (or `rollup-plugin-dts`'s
+     * tsconfig integration) so TypeScript source workspace deps can be hoisted.
+     */
+    kind: PrePassWorkerJobKind;
+    /** Dep package name (or workspace specifier) being pre-passed. */
+    dep: string;
+    /** Absolute path to the dep's entry (main / module for JS, types for dts, source `.ts` for workspace-*). */
+    inputPath: string;
+    /** Output format. JS jobs must use `'esm'` or `'cjs'`. dts jobs always use `'es'` internally. */
+    format: 'esm' | 'cjs';
+    /** Absolute path to the output file. */
+    outputPath: string;
+    /** Other deps in the pre-pass set; marked external so cross-dep imports stay link-time. Prefix-matched. */
+    otherDeps: string[];
+    /**
+     * Sub-path-mode workspace specifiers in the pre-pass set; matched as exact
+     * specifier only (e.g. `@hyperfrontend/immutable-api-utils/built-in-copy/array`).
+     * Used by `workspace-*` jobs so sibling sub-paths externalize cleanly without
+     * also externalizing every other sub-path on the same package.
+     */
+    otherWorkspaceSpecifiers?: string[];
+    /** Absolute path to the project's tsconfig (workspace-* jobs only). */
+    tsConfigPath?: string;
+    /** Absolute workspace root used as `baseUrl` for path-mapping resolution (workspace-* jobs only). */
+    workspaceRoot?: string;
+    /**
+     * Sibling-entry descriptors used by the per-entry `dts` pass to externalize
+     * imports that resolve into another entry's directory. Empty / omitted for
+     * dep pre-pass jobs.
+     */
+    siblingEntries?: SiblingEntry[];
+    /** Absolute path to the input file's owning entry directory (used to compute sibling specifiers). */
+    selfDtsPath?: string;
+    /** Owning entry's `srcPath` (used for diagnostics). Empty string for the package root. */
+    selfSrcPath?: string;
+    /**
+     * NPM bundled-dep names consumed by the canonical externalize plugin to rewrite
+     * cross-dep imports to relative paths under {@link depsRoot}.
+     */
+    npmDeps?: string[];
+    /**
+     * Workspace bundled-dep routes consumed by the canonical externalize plugin.
+     * For self-pre-pass jobs (`workspace-js` / `workspace-dts`) this excludes the
+     * specifier or package being built so the chunk inlines its own internals.
+     */
+    workspaceRoutes?: WorkspaceBundledDepRoute[];
+    /** Absolute path to the project's `_dependencies/` root. Required when {@link npmDeps} or {@link workspaceRoutes} is non-empty. */
+    depsRoot?: string;
+    /** Absolute path where the worker writes its JSON report. */
+    reportPath: string;
+}
+/**
+ * Memory + size summary written to `reportPath` when a worker exits cleanly.
+ */
+interface PrePassWorkerReport {
+    /** Final on-disk size of the rollup output, in bytes. */
+    outputSize: number;
+    /** `process.memoryUsage().heapUsed` in MB at end of bundle. */
+    endHeapMB: number;
+    /** `process.memoryUsage().rss` in MB at end of bundle. */
+    endRssMB: number;
+    /** Worker wall-clock duration in ms. */
+    durationMs: number;
+}
+/**
+ * Runs a single pre-pass rollup invocation as described by `job` and writes the
+ * resulting report to `job.reportPath`.
+ *
+ * Public so callers (and tests) can drive the worker logic without spawning a
+ * new Node process.
+ *
+ * @param job - Job spec describing the rollup invocation.
+ * @returns The on-disk report data the worker would have persisted.
+ *
+ * @example Driving the worker logic in-process for a fixture
+ * ```typescript
+ * const report = await runPrePassWorkerJob({ kind: 'js', dep: 'rollup', ... })
+ * ```
+ */
+declare const runPrePassWorkerJob: (job: PrePassWorkerJob) => Promise<PrePassWorkerReport>;
+
+export { runPrePassWorkerJob };
+export type { PrePassWorkerJob, PrePassWorkerReport };

package/bundle/dependencies/worker/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/worker/index.ts"],"names":[],"mappings":"AAWA,YAAY,EAAE,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AACzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA"}

package/bundle/dependencies/worker/index.esm.js

@@ -0,0 +1,515 @@
+import { statSync, writeFileSync, mkdirSync } from 'node:fs';
+import { isBuiltin } from 'node:module';
+import { join as join$1, isAbsolute, resolve, relative, dirname } from 'node:path';
+import commonjs from '../../../_dependencies/@rollup/plugin-commonjs/index.esm.js';
+import json from '../../../_dependencies/@rollup/plugin-json/index.esm.js';
+import nodeResolve from '../../../_dependencies/@rollup/plugin-node-resolve/index.esm.js';
+import typescript from '../../../_dependencies/@rollup/plugin-typescript/index.esm.js';
+import { rollup } from '../../../_dependencies/rollup/index.esm.js';
+import { normalizeToForwardSlashes, join } from '../../../_shared/bundle/fs/posix-path/index.esm.js';
+import { createExternalizeBundledDepsPlugin } from '../../../_shared/bundle/dependencies/externalize-plugin/index.esm.js';
+
+const stripTrailingIndexDts = (filePath) => {
+    const normalized = normalizeToForwardSlashes(filePath);
+    const trimmed = normalized.replace(/\/index\.d\.ts$/, '');
+    return trimmed === normalized ? normalized.replace(/\.d\.ts$/, '') : trimmed;
+};
+const stripTrailingSlash = (value) => (value.endsWith('/') ? value.slice(0, -1) : value);
+const dirnameOf = (filePath) => {
+    const normalized = normalizeToForwardSlashes(filePath);
+    const idx = normalized.lastIndexOf('/');
+    return idx <= 0 ? normalized : normalized.slice(0, idx);
+};
+/**
+ * Computes the directory (without trailing slash) that owns a sibling's
+ * `index.d.ts`. Used to test whether an absolute resolved id falls inside the
+ * sibling's directory tree.
+ *
+ * @param sibling - Sibling-entry record.
+ * @returns Sibling's directory with no trailing slash.
+ */
+const siblingDir = (sibling) => stripTrailingSlash(dirnameOf(sibling.indexDtsPath));
+const startsWithDir = (resolved, dir) => {
+    const normalizedResolved = normalizeToForwardSlashes(resolved);
+    if (normalizedResolved === dir)
+        return true;
+    return normalizedResolved.startsWith(`${dir}/`);
+};
+/**
+ * Returns the sibling entry whose directory contains `absolutePath`, or `undefined`
+ * when no sibling owns the path.
+ *
+ * @param absolutePath - Resolved absolute path of an import.
+ * @param siblings - Sibling-entry records.
+ * @returns Owning sibling entry, or `undefined`.
+ *
+ * @example Identifying a sibling for a resolved type import
+ * ```typescript
+ * const owner = findOwningSibling('/abs/dist/libs/foo/models/index.d.ts', siblings)
+ * ```
+ */
+const findOwningSibling = (absolutePath, siblings) => {
+    const normalized = normalizeToForwardSlashes(absolutePath);
+    let best;
+    let bestDirLength = -1;
+    for (const sibling of siblings) {
+        const dir = siblingDir(sibling);
+        if (!startsWithDir(normalized, dir))
+            continue;
+        if (dir.length > bestDirLength) {
+            best = sibling;
+            bestDirLength = dir.length;
+        }
+    }
+    return best;
+};
+/**
+ * Computes the bare-specifier form of a sibling import as emitted in the
+ * rewritten `.d.ts` (e.g., `../models`, `../../models`, `./bundle/declarations`).
+ *
+ * Always omits the trailing `index.d.ts` so both `moduleResolution: 'bundler'`
+ * and `node` accept it.
+ *
+ * @param selfDtsPath - Absolute path to the current entry's `index.d.ts`.
+ * @param sibling - The sibling entry being targeted.
+ * @returns POSIX-style relative specifier ready for `id` in a rollup external resolution.
+ *
+ * @example Computing a sibling import from `bundle/index.d.ts` to `models/`
+ * ```typescript
+ * computeSiblingSpecifier(
+ *   '/abs/dist/libs/foo/bundle/index.d.ts',
+ *   { srcPath: 'models', indexDtsPath: '/abs/dist/libs/foo/models/index.d.ts' }
+ * ) // => '../models'
+ * ```
+ */
+const computeSiblingSpecifier = (selfDtsPath, sibling) => {
+    const fromDir = dirnameOf(selfDtsPath);
+    const toDir = siblingDir(sibling);
+    const fromSegments = fromDir.split('/').filter((s) => s.length > 0);
+    const toSegments = toDir.split('/').filter((s) => s.length > 0);
+    let common = 0;
+    while (common < fromSegments.length && common < toSegments.length && fromSegments[common] === toSegments[common]) {
+        common += 1;
+    }
+    const upSegments = fromSegments.length - common;
+    const downSegments = toSegments.slice(common);
+    if (upSegments === 0 && downSegments.length === 0)
+        return '.';
+    const ups = '../'.repeat(upSegments);
+    const downs = downSegments.join('/');
+    if (upSegments === 0)
+        return `./${downs}`;
+    return downs.length > 0 ? `${ups}${downs}` : ups.replace(/\/$/, '');
+};
+/**
+ * Resolves a relative or absolute `source` against `importer` (or `selfDtsPath`
+ * when no importer is given) and returns the absolute filesystem candidate
+ * suitable for matching against sibling entries.
+ *
+ * Mirrors TypeScript's lookup rules at the level we need: when the candidate
+ * exists as `<candidate>/index.d.ts` we treat that as the resolved file,
+ * otherwise the candidate path itself.
+ *
+ * @param source - The import specifier as it appears in source.
+ * @param importer - Absolute path of the importing module, when known.
+ * @param selfDtsPath - Absolute path to the entry currently being rewritten (fallback importer).
+ * @returns Absolute candidate path for sibling matching.
+ */
+const resolveCandidate = (source, importer, selfDtsPath) => {
+    if (isAbsolute(source))
+        return normalizeToForwardSlashes(source);
+    if (source.startsWith('.')) {
+        const fromDir = dirnameOf(importer ?? selfDtsPath);
+        return normalizeToForwardSlashes(resolve(fromDir, source));
+    }
+    return source;
+};
+/**
+ * Returns a rollup plugin that externalizes any import resolving inside a
+ * sibling entry's directory tree, rewriting the emitted specifier to a POSIX
+ * relative path stripped of `/index` and `.d.ts` suffixes.
+ *
+ * The plugin's `resolveId` hook returns `null` for everything that does not
+ * resolve into a sibling — that lets the rest of the rollup-plugin-dts chain
+ * inline third-party type imports as before.
+ *
+ * Self-ownership is enforced by adding the current entry into the ownership
+ * pool: when the deepest-matching entry directory is the entry being rewritten
+ * (and not a sibling), the resolver returns `null` so rollup keeps the path
+ * internal. This matters for the package root entry whose directory prefix-
+ * matches every other entry's path — without including self, root would
+ * spuriously claim its own subtree's files.
+ *
+ * @param input - Self + sibling entry descriptors.
+ * @returns Rollup plugin.
+ *
+ * @example Plugin instance for the bundle entry pass
+ * ```typescript
+ * const plugin = createSiblingExternalizePlugin({
+ *   selfSrcPath: 'bundle',
+ *   selfDtsPath: '/abs/dist/libs/foo/bundle/index.d.ts',
+ *   siblings: [{ srcPath: 'models', indexDtsPath: '/abs/dist/libs/foo/models/index.d.ts' }],
+ * })
+ * ```
+ */
+const createSiblingExternalizePlugin = (input) => {
+    const { selfSrcPath, selfDtsPath, siblings } = input;
+    const selfEntry = { srcPath: selfSrcPath, indexDtsPath: selfDtsPath };
+    const ownershipPool = [selfEntry, ...siblings];
+    const selfDtsResolved = normalizeToForwardSlashes(selfDtsPath);
+    return {
+        name: 'externalize-sibling-subpaths',
+        resolveId(source, importer) {
+            if (siblings.length === 0)
+                return null;
+            const candidate = resolveCandidate(source, importer, selfDtsPath);
+            const indexCandidate = candidate.endsWith('.d.ts') ? candidate : `${stripTrailingIndexDts(candidate)}/index.d.ts`;
+            const owner = findOwningSibling(candidate, ownershipPool) ?? findOwningSibling(indexCandidate, ownershipPool);
+            if (!owner)
+                return null;
+            if (normalizeToForwardSlashes(owner.indexDtsPath) === selfDtsResolved)
+                return null;
+            return { id: computeSiblingSpecifier(selfDtsPath, owner), external: true };
+        },
+    };
+};
+
+const BYTES_PER_MB = 1024 * 1024;
+const SUPPRESSED_WARNING_CODES = new Set([
+    'CIRCULAR_DEPENDENCY',
+    'UNRESOLVED_IMPORT',
+    'EMPTY_BUNDLE',
+    'UNUSED_EXTERNAL_IMPORT',
+    'MIXED_EXPORTS',
+]);
+/**
+ * Suppresses `MISSING_EXPORT` warnings caused by a package augmenting a
+ * DefinitelyTyped (`@types/*`) module to add members absent from the published
+ * stub. `rollup-plugin-dts` resolves e.g. `import * as estree from 'estree'` to
+ * `@types/estree` but cannot follow the `declare module 'estree'` augmentation
+ * (rollup's own `rollup.d.ts` adds `Decorator` this way) across the external
+ * boundary, so it reports the augmented members as not exported. The
+ * augmentation still resolves correctly in the emitted d.ts, so the warning is
+ * noise during the d.ts pre-pass.
+ *
+ * @param warning - The rollup log entry.
+ * @returns `true` when the warning is a `@types/*` augmentation false positive.
+ */
+const isTypesAugmentationMiss = (warning) => warning.code === 'MISSING_EXPORT' && typeof warning.exporter === 'string' && warning.exporter.includes('/@types/');
+/**
+ * Shared rollup `onwarn` handler for every pre-pass job. Drops the known-benign
+ * warning classes that bundling third-party / workspace deps routinely emits
+ * (see {@link SUPPRESSED_WARNING_CODES} and {@link isTypesAugmentationMiss}) and
+ * forwards everything else to rollup's default handler.
+ *
+ * @param warning - The rollup log entry.
+ * @param defaultHandler - Rollup's default warning handler.
+ *
+ * @example Wiring the handler into a rollup config
+ * ```typescript
+ * const config: RollupOptions = { input, plugins, onwarn: onWarn }
+ * ```
+ */
+const onWarn = (warning, defaultHandler) => {
+    if (warning.code && SUPPRESSED_WARNING_CODES.has(warning.code))
+        return;
+    if (isTypesAugmentationMiss(warning))
+        return;
+    defaultHandler(warning);
+};
+const matchesAnyDep = (id, deps) => {
+    for (const d of deps) {
+        if (id === d || id.startsWith(`${d}/`))
+            return true;
+    }
+    return false;
+};
+const matchesAnyExactSpecifier = (id, specifiers) => {
+    if (!specifiers || specifiers.length === 0)
+        return false;
+    for (const s of specifiers) {
+        if (id === s)
+            return true;
+    }
+    return false;
+};
+/**
+ * Packages whose JS implementation is intentionally NOT inlined during the JS pre-pass.
+ *
+ * Mirrors `ALWAYS_EXTERNAL_TYPE_DEPS` for the JS half. `typescript` is permanent
+ * consumer-supplied — both `@rollup/plugin-typescript` and `rollup-plugin-dts`
+ * follow `require('typescript')` into the compiler; without this gate, ~30 MB
+ * of typescript bytecode ends up inlined into `_dependencies/<plugin>/index.<fmt>.js`.
+ */
+const ALWAYS_EXTERNAL_JS_DEPS = new Set(['typescript']);
+const isExternalJsDep = (id) => {
+    for (const name of ALWAYS_EXTERNAL_JS_DEPS) {
+        if (id === name || id.startsWith(`${name}/`))
+            return true;
+    }
+    return false;
+};
+/**
+ * Builds the canonical externalize plugin for a pre-pass job when the parent
+ * supplied npm deps or workspace routes. Mirrors the plugin install on the
+ * per-entry rollup side so chunk-internal cross-bundled-dep specifiers get
+ * rewritten to relative paths under `_dependencies/` instead of leaking as bare
+ * `require('@hyperfrontend/...')` calls into the published artifact.
+ *
+ * @param job - Pre-pass job spec; only `npmDeps`, `workspaceRoutes`, `depsRoot`, and `outputPath` are read here.
+ * @param format - Output format the plugin should rewrite specifiers for (`'esm'`, `'cjs'`, or `'dts'`).
+ * @returns The plugin when routing data is supplied, or `undefined` to opt out of rewriting.
+ */
+const maybeExternalizePlugin = (job, format) => {
+    const npmDeps = job.npmDeps ?? [];
+    const workspaceRoutes = job.workspaceRoutes ?? [];
+    if (npmDeps.length === 0 && workspaceRoutes.length === 0)
+        return undefined;
+    if (!job.depsRoot)
+        return undefined;
+    return createExternalizeBundledDepsPlugin({
+        deps: npmDeps,
+        entryOutDir: dirname(job.outputPath),
+        format,
+        depsRoot: job.depsRoot,
+        workspaceRoutes,
+    });
+};
+const buildJsConfig = (job) => {
+    const plugins = [];
+    const externalizePlugin = maybeExternalizePlugin(job, job.format);
+    const hasExternalize = externalizePlugin !== undefined;
+    if (externalizePlugin)
+        plugins.push(externalizePlugin);
+    plugins.push(json(), nodeResolve({ preferBuiltins: true, extensions: ['.mjs', '.js', '.cjs', '.json'] }), commonjs({ ignoreDynamicRequires: true }));
+    return {
+        input: job.inputPath,
+        // why: when the externalize plugin is active, it owns rewriting of bundled-dep specifiers to relative paths under depsRoot. The `external` callback must not short-circuit those — rollup consults `external` before plugin resolveId can run, so any matchesAnyDep hit there leaks bare specifiers into the chunk.
+        external: (id) => isBuiltin(id) || id.startsWith('node:') || (!hasExternalize && matchesAnyDep(id, job.otherDeps)) || isExternalJsDep(id),
+        onwarn: onWarn,
+        plugins,
+    };
+};
+const requireWorkspaceField = (job, field) => {
+    const value = job[field];
+    if (!value) {
+        throw new Error(`workspace pre-pass job for ${job.dep} (${job.kind}/${job.format}) missing ${field}`);
+    }
+    return value;
+};
+/**
+ * Builds a JS rollup config for a workspace-source pre-pass. The input is a
+ * `.ts` source file; `@rollup/plugin-typescript` transpiles it (and any
+ * transitive workspace files reached via tsconfig path-mapping) while sibling
+ * pre-passed specifiers stay external so each chunk is self-contained.
+ *
+ * The plugin is driven by the dep's own tsconfig (resolved by the parent and
+ * passed through `job.tsConfigPath`), keeping the workspace pre-pass agnostic
+ * of any workspace-root tsconfig.
+ *
+ * @param job - Pre-pass job spec with `tsConfigPath` and `workspaceRoot` populated.
+ * @returns Rollup options ready for the worker to invoke.
+ */
+const buildWorkspaceJsConfig = (job) => {
+    const tsConfigPath = requireWorkspaceField(job, 'tsConfigPath');
+    const workspaceRoot = requireWorkspaceField(job, 'workspaceRoot');
+    const tsPlugin = typescript({
+        tsconfig: tsConfigPath,
+        declaration: false,
+        declarationMap: false,
+        sourceMap: false,
+        compilerOptions: {
+            baseUrl: workspaceRoot,
+            outDir: dirname(job.outputPath),
+            noEmitOnError: false,
+            noEmit: false,
+            module: 'esnext',
+        },
+    });
+    const plugins = [];
+    const externalizePlugin = maybeExternalizePlugin(job, job.format);
+    const hasExternalize = externalizePlugin !== undefined;
+    if (externalizePlugin)
+        plugins.push(externalizePlugin);
+    plugins.push(json(), nodeResolve({ preferBuiltins: true, extensions: ['.ts', '.mjs', '.js', '.cjs', '.json'] }), commonjs({ ignoreDynamicRequires: true }), tsPlugin);
+    return {
+        input: job.inputPath,
+        external: (id) => isBuiltin(id) ||
+            id.startsWith('node:') ||
+            (!hasExternalize && matchesAnyDep(id, job.otherDeps)) ||
+            (!hasExternalize && matchesAnyExactSpecifier(id, job.otherWorkspaceSpecifiers)) ||
+            isExternalJsDep(id),
+        onwarn: onWarn,
+        plugins,
+    };
+};
+const buildJsOutput = (job) => ({
+    file: job.outputPath,
+    format: job.format === 'esm' ? 'esm' : 'cjs',
+    sourcemap: false,
+    inlineDynamicImports: true,
+    exports: 'auto',
+    generatedCode: { constBindings: true },
+});
+/**
+ * Packages whose `.d.ts` is intentionally NOT inlined during the d.ts pre-pass.
+ *
+ * `typescript` is a permanent consumer requirement — never bundled, never inlined,
+ * never copied into `_dependencies/`. The compiler is too large (~10 MB just for
+ * `lib/typescript.d.ts`), its namespace re-exports defeat `rollup-plugin-dts`,
+ * and every consumer of `@hyperfrontend/builder` is, by definition, already a
+ * TypeScript project. Emitted `.d.ts` keeps `import type ... from 'typescript'`
+ * intact so the consumer's own install satisfies the type imports.
+ */
+const ALWAYS_EXTERNAL_TYPE_DEPS = new Set(['typescript']);
+const isExternalTypeDep = (id) => {
+    for (const name of ALWAYS_EXTERNAL_TYPE_DEPS) {
+        if (id === name || id.startsWith(`${name}/`))
+            return true;
+    }
+    return false;
+};
+const loadDtsFactory = async () => {
+    const dtsModule = await import('../../../_dependencies/rollup-plugin-dts/index.esm.js');
+    /* istanbul ignore next -- @preserve fallback path for CJS-style rollup-plugin-dts module shapes */
+    return (dtsModule.default ?? dtsModule);
+};
+const maybeSiblingPlugin = (job) => {
+    if (!job.siblingEntries || job.siblingEntries.length === 0 || !job.selfDtsPath)
+        return undefined;
+    return createSiblingExternalizePlugin({
+        selfSrcPath: job.selfSrcPath ?? '',
+        selfDtsPath: job.selfDtsPath,
+        siblings: job.siblingEntries,
+    });
+};
+const buildDtsConfig = async (job) => {
+    const dtsFactory = await loadDtsFactory();
+    const plugins = [];
+    const siblingPlugin = maybeSiblingPlugin(job);
+    if (siblingPlugin)
+        plugins.push(siblingPlugin);
+    const externalizePlugin = maybeExternalizePlugin(job, 'dts');
+    const hasExternalize = externalizePlugin !== undefined;
+    if (externalizePlugin)
+        plugins.push(externalizePlugin);
+    plugins.push(dtsFactory({ respectExternal: true }));
+    return {
+        input: job.inputPath,
+        external: (id) => isBuiltin(id) || id.startsWith('node:') || (!hasExternalize && matchesAnyDep(id, job.otherDeps)) || isExternalTypeDep(id),
+        onwarn: onWarn,
+        plugins,
+    };
+};
+/**
+ * Builds a d.ts rollup config for a workspace-source pre-pass. The input is a
+ * `.ts` source file; `rollup-plugin-dts` drives TypeScript using the project's
+ * tsconfig so workspace path-mappings resolve and transitive type imports are
+ * properly inlined or externalized.
+ *
+ * @param job - Pre-pass job spec with `tsConfigPath` and `workspaceRoot` populated.
+ * @returns Rollup options ready for the worker to invoke.
+ */
+const buildWorkspaceDtsConfig = async (job) => {
+    const tsConfigPath = requireWorkspaceField(job, 'tsConfigPath');
+    const workspaceRoot = requireWorkspaceField(job, 'workspaceRoot');
+    const dtsFactory = await loadDtsFactory();
+    const plugins = [];
+    const externalizePlugin = maybeExternalizePlugin(job, 'dts');
+    const hasExternalize = externalizePlugin !== undefined;
+    if (externalizePlugin)
+        plugins.push(externalizePlugin);
+    plugins.push(dtsFactory({ respectExternal: true, tsconfig: tsConfigPath, compilerOptions: { baseUrl: workspaceRoot } }));
+    return {
+        input: job.inputPath,
+        external: (id) => isBuiltin(id) ||
+            id.startsWith('node:') ||
+            (!hasExternalize && matchesAnyDep(id, job.otherDeps)) ||
+            (!hasExternalize && matchesAnyExactSpecifier(id, job.otherWorkspaceSpecifiers)) ||
+            isExternalTypeDep(id),
+        onwarn: onWarn,
+        plugins,
+    };
+};
+const buildDtsOutput = (job) => ({
+    file: job.outputPath,
+    format: 'es',
+    sourcemap: false,
+    inlineDynamicImports: true,
+});
+const ensureParentDir = (filePath) => {
+    mkdirSync(dirname(filePath), { recursive: true });
+};
+const buildConfigForJob = async (job) => {
+    switch (job.kind) {
+        case 'dts':
+            return buildDtsConfig(job);
+        case 'workspace-js':
+            return buildWorkspaceJsConfig(job);
+        case 'workspace-dts':
+            return buildWorkspaceDtsConfig(job);
+        default:
+            return buildJsConfig(job);
+    }
+};
+/**
+ * Runs a single pre-pass rollup invocation as described by `job` and writes the
+ * resulting report to `job.reportPath`.
+ *
+ * Public so callers (and tests) can drive the worker logic without spawning a
+ * new Node process.
+ *
+ * @param job - Job spec describing the rollup invocation.
+ * @returns The on-disk report data the worker would have persisted.
+ *
+ * @example Driving the worker logic in-process for a fixture
+ * ```typescript
+ * const report = await runPrePassWorkerJob({ kind: 'js', dep: 'rollup', ... })
+ * ```
+ */
+const runPrePassWorkerJob = async (job) => {
+    const startedAt = Date.now();
+    ensureParentDir(job.outputPath);
+    ensureParentDir(job.reportPath);
+    const config = await buildConfigForJob(job);
+    const output = job.kind === 'dts' || job.kind === 'workspace-dts' ? buildDtsOutput(job) : buildJsOutput(job);
+    const bundle = await rollup(config);
+    try {
+        await bundle.write(output);
+    }
+    finally {
+        await bundle.close();
+    }
+    const memory = process.memoryUsage();
+    const report = {
+        outputSize: statSync(job.outputPath).size,
+        endHeapMB: memory.heapUsed / BYTES_PER_MB,
+        endRssMB: memory.rss / BYTES_PER_MB,
+        durationMs: Date.now() - startedAt,
+    };
+    writeFileSync(job.reportPath, JSON.stringify(report));
+    return report;
+};
+
+const isMainModule = () => {
+    if (typeof require !== 'undefined' && typeof module !== 'undefined' && require.main === module) {
+        return true;
+    }
+    const argv1 = process.argv[1] ?? '';
+    return argv1.endsWith('index.cjs.js') || argv1.endsWith('index.esm.js') || argv1.endsWith('index.ts') || argv1.endsWith('index.js');
+};
+if (isMainModule()) {
+    const raw = process.argv[2];
+    if (!raw) {
+        process.stderr.write('pre-pass worker: missing job spec on argv\n');
+        process.exit(2);
+    }
+    const job = JSON.parse(raw);
+    runPrePassWorkerJob(job).then(() => process.exit(0), (error) => {
+        const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+        process.stderr.write(`pre-pass worker for ${job.dep}/${job.kind}/${job.format} failed: ${message}\n`);
+        process.exit(1);
+    });
+}
+
+export { runPrePassWorkerJob };