@hyperfrontend/builder 0.1.0

package/bundle/rollup/index.esm.js

@@ -0,0 +1,698 @@
+import { join as join$3, getDirname } from '../../_dependencies/@hyperfrontend/project-scope/core/path/index.esm.js';
+import { isBuiltin } from 'node:module';
+import { join as join$1, relative, dirname } from 'node:path';
+import { from } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.esm.js';
+import { keys } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.esm.js';
+import { createSet } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/set/index.esm.js';
+import { exists, readJsonFile } from '../../_dependencies/@hyperfrontend/project-scope/core/fs/index.esm.js';
+import { createError } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.esm.js';
+import { join as join$2 } from '../../_dependencies/@hyperfrontend/project-scope/core/index.esm.js';
+import { spawn } from 'node:child_process';
+import { rmSync, existsSync, mkdtempSync, readFileSync, chmodSync, writeFileSync, mkdirSync, statSync } 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 { createPromise } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/promise/index.esm.js';
+import { logger } from '../../_dependencies/@hyperfrontend/logging/index.esm.js';
+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 terser from '../../_dependencies/@rollup/plugin-terser/index.esm.js';
+import typescript from '../../_dependencies/@rollup/plugin-typescript/index.esm.js';
+import { rollup } from '../../_dependencies/rollup/index.esm.js';
+import { defaultBootstrap } from '../../_shared/bin/script/bootstrap-footer/index.esm.js';
+import { join } from '../../_shared/bundle/fs/posix-path/index.esm.js';
+import { buildWorkspaceRoutes, createExternalizeBundledDepsPlugin } 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';
+
+const readPkg = (packageJsonPath) => (exists(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,
+    };
+};
+const SHEBANG = '#!/usr/bin/env node';
+const BIN_FILE_MODE = 0o755;
+const resolveBinOutputFile = (binDir, name, format, formats) => {
+    if (format === 'esm')
+        return join$3(binDir, `${name}.mjs`);
+    return formats.length === 1 ? join$3(binDir, `${name}.js`) : join$3(binDir, `${name}.cjs.js`);
+};
+const resolveBinFooter = (bin, format) => bin.bootstrap ?? defaultBootstrap({ runner: bin.runner ?? 'default', format });
+/**
+ * Builds the worker descriptor for a single bin output (one (bin, format) pair).
+ *
+ * Bins are self-contained executable scripts: workspace deps are inlined and the
+ * worker writes to `<outputPath>/bin/<name>.<ext>` with the shebang banner, the
+ * resolved bootstrap footer, and `chmod 0o755` applied.
+ *
+ * Output naming convention:
+ * - ESM: `<name>.mjs`
+ * - CJS only: `<name>.js`
+ * - CJS alongside ESM: `<name>.cjs.js`
+ *
+ * @param bin - Bin declaration including name, runner, and per-bin bootstrap override.
+ * @param context - Resolved build context.
+ * @param format - Format being built (one of `bin.format`'s entries).
+ * @param formats - Full list of formats requested for this bin (drives the CJS filename).
+ * @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 an `hf-build` CJS bin alongside an ESM twin
+ * ```typescript
+ * const descriptor = toBinBuildDescriptor(bin, context, 'cjs', ['cjs', 'esm'], '/tmp/r.json')
+ * ```
+ */
+const toBinBuildDescriptor = (bin, context, format, formats, reportPath) => {
+    const inputFile = join$3(context.projectRoot, 'src', 'bin', `${bin.name}.ts`);
+    const binDir = join$3(context.outputPath, 'bin');
+    const outputFile = resolveBinOutputFile(binDir, bin.name, format, formats);
+    const bundledDepsRoot = depsRootOf(context);
+    const workspaceRoutes = buildWorkspaceRoutes(context.workspaceBundledDeps);
+    const useExternalizePlugin = context.bundledDeps.length > 0 || workspaceRoutes.length > 0;
+    return {
+        format,
+        inputFile,
+        outputDir: getDirname(outputFile),
+        external: [],
+        sourcemap: false,
+        bundledDepsPlugin: useExternalizePlugin ? { deps: context.bundledDeps, depsRoot: bundledDepsRoot } : null,
+        workspaceRoutes,
+        tsConfigPath: context.tsConfigPath,
+        projectRoot: context.projectRoot,
+        workspaceRoot: context.workspaceRoot,
+        bundleWorkspaceDeps: true,
+        bundle: null,
+        bin: {
+            outputFile,
+            banner: SHEBANG,
+            footer: resolveBinFooter(bin, format),
+            exports: 'named',
+            inlineDynamicImports: true,
+            chmod: BIN_FILE_MODE,
+        },
+        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 = 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.info(`rollup dispatch: ${label}`);
+        await runOne(job, options, label);
+        const report = readReport(reportPath, label);
+        log.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 BYTES_PER_MB = 1024 * 1024;
+const importMatchesWorkspaceRoute = (id, routes) => {
+    /* istanbul ignore if -- @preserve defensive: rollup always populates `exporter` on UNRESOLVED_IMPORT warnings */
+    if (id === undefined)
+        return false;
+    for (const route of routes) {
+        if (id === route.packageName || id.startsWith(`${route.packageName}/`))
+            return true;
+    }
+    return false;
+};
+const onWarnEntry = (warning, defaultHandler, workspaceRoutes) => {
+    // why: under bundleAllDeps the externalize plugin is the sole owner of workspace-dep resolution; an unresolved import of a routed package means it slipped past routing and would ship as a bare external specifier — fail loud rather than emit a broken artifact.
+    if (warning.code === 'UNRESOLVED_IMPORT' && importMatchesWorkspaceRoute(warning.exporter, workspaceRoutes)) {
+        throw new Error(`bundle: workspace import "${warning.exporter}" was not routed into _dependencies/ and would leak as an external import. Confirm it is declared in package.json#dependencies and mapped in tsconfig paths; subpath-only packages require a 'sub-path' workspaceDepPolicy entry.`);
+    }
+    if (warning.plugin === 'typescript' && warning.message?.includes('TS2307'))
+        return;
+    if (warning.code === 'EMPTY_BUNDLE')
+        return;
+    defaultHandler(warning);
+};
+const onWarnBundle = (warning, defaultHandler) => {
+    if (warning.plugin === 'typescript' && warning.message?.includes('TS2307'))
+        return;
+    if (warning.code === 'EMPTY_BUNDLE')
+        return;
+    if (warning.code === 'UNRESOLVED_IMPORT')
+        return;
+    defaultHandler(warning);
+};
+const buildExternalPredicate = (externals) => {
+    const set = new Set(externals);
+    return (id) => set.has(id);
+};
+const buildEntryPlugins = (job, format) => {
+    const plugins = [];
+    const hasWorkspaceRoutes = job.workspaceRoutes.length > 0;
+    if (job.bundledDepsPlugin) {
+        plugins.push(createExternalizeBundledDepsPlugin({
+            deps: job.bundledDepsPlugin.deps,
+            entryOutDir: job.outputDir,
+            format,
+            depsRoot: job.bundledDepsPlugin.depsRoot,
+            workspaceRoutes: job.workspaceRoutes,
+        }));
+    }
+    // why: when workspaceRoutes is populated, the externalize plugin owns @hyperfrontend/* resolution; the typescript plugin's baseUrl path-mapping must not preempt it. Falling through to the paths:{} branch lets externalize win.
+    const useBaseUrlMapping = job.bundleWorkspaceDeps && !hasWorkspaceRoutes;
+    plugins.push(json(), nodeResolve({ extensions: ['.ts', '.js'] }), commonjs(), useBaseUrlMapping ? typescript({
+        tsconfig: job.tsConfigPath,
+        declaration: false,
+        declarationMap: false,
+        sourceMap: job.sourcemap,
+        compilerOptions: {
+            baseUrl: job.workspaceRoot,
+            outDir: job.outputDir,
+        },
+    }) : typescript({
+        tsconfig: job.tsConfigPath,
+        declaration: false,
+        declarationMap: false,
+        rootDir: `${job.projectRoot}/src`,
+        outDir: job.outputDir,
+        sourceMap: job.sourcemap,
+        compilerOptions: { paths: {} },
+    }));
+    return plugins;
+};
+const buildBundlePlugins = (job) => [
+    json(),
+    nodeResolve({ extensions: ['.ts', '.js'], browser: true, preferBuiltins: false }),
+    commonjs(),
+    typescript({
+        tsconfig: job.tsConfigPath,
+        declaration: false,
+        declarationMap: false,
+        sourceMap: true,
+        compilerOptions: {
+            baseUrl: job.workspaceRoot,
+            outDir: job.outputDir,
+        },
+    }),
+];
+const buildEntryOutput = (job, format) => {
+    if (job.bin) {
+        return {
+            file: job.bin.outputFile,
+            format,
+            sourcemap: job.sourcemap,
+            banner: job.bin.banner,
+            footer: job.bin.footer,
+            exports: job.bin.exports,
+            inlineDynamicImports: job.bin.inlineDynamicImports,
+            generatedCode: { constBindings: true },
+            ...(format === 'cjs' && { interop: 'compat' }),
+        };
+    }
+    const filename = format === 'esm' ? 'index.esm.js' : 'index.cjs.js';
+    return {
+        file: join$1(job.outputDir, filename),
+        format,
+        sourcemap: job.sourcemap,
+        generatedCode: { constBindings: true },
+        ...(format === 'cjs' && { interop: 'compat' }),
+    };
+};
+const buildEsmJob = (job) => ({
+    config: {
+        input: job.inputFile,
+        external: buildExternalPredicate(job.external),
+        onwarn: (warning, defaultHandler) => onWarnEntry(warning, defaultHandler, job.workspaceRoutes),
+        plugins: buildEntryPlugins(job, 'esm'),
+    },
+    outputs: [buildEntryOutput(job, 'esm')],
+});
+const buildCjsJob = (job) => ({
+    config: {
+        input: job.inputFile,
+        external: buildExternalPredicate(job.external),
+        onwarn: (warning, defaultHandler) => onWarnEntry(warning, defaultHandler, job.workspaceRoutes),
+        plugins: buildEntryPlugins(job, 'cjs'),
+    },
+    outputs: [buildEntryOutput(job, 'cjs')],
+});
+const buildIifeJob = (job) => {
+    const bundle = job.bundle;
+    const outputs = [
+        {
+            file: join$1(job.outputDir, 'index.iife.js'),
+            format: 'iife',
+            name: bundle.globalName,
+            sourcemap: job.sourcemap,
+            globals: bundle.globals,
+        },
+    ];
+    if (bundle.minify) {
+        outputs.push({
+            file: join$1(job.outputDir, 'index.iife.min.js'),
+            format: 'iife',
+            name: bundle.globalName,
+            sourcemap: job.sourcemap,
+            globals: bundle.globals,
+            plugins: [terser()],
+        });
+    }
+    return {
+        config: {
+            input: job.inputFile,
+            external: buildExternalPredicate(job.external),
+            onwarn: onWarnBundle,
+            plugins: buildBundlePlugins(job),
+        },
+        outputs,
+    };
+};
+const buildUmdJob = (job) => {
+    const bundle = job.bundle;
+    const base = {
+        format: 'umd',
+        name: bundle.globalName,
+        sourcemap: job.sourcemap,
+        globals: bundle.globals,
+    };
+    if (bundle.amdId)
+        base.amd = { id: bundle.amdId };
+    const outputs = [{ ...base, file: join$1(job.outputDir, 'index.umd.js') }];
+    if (bundle.minify) {
+        outputs.push({ ...base, file: join$1(job.outputDir, 'index.umd.min.js'), plugins: [terser()] });
+    }
+    return {
+        config: {
+            input: job.inputFile,
+            external: buildExternalPredicate(job.external),
+            onwarn: onWarnBundle,
+            plugins: buildBundlePlugins(job),
+        },
+        outputs,
+    };
+};
+const buildJob = (job) => {
+    if (job.format === 'esm')
+        return buildEsmJob(job);
+    if (job.format === 'cjs')
+        return buildCjsJob(job);
+    if (job.format === 'iife')
+        return buildIifeJob(job);
+    return buildUmdJob(job);
+};
+const ensureDir = (path) => {
+    mkdirSync(path, { recursive: true });
+};
+const safeStatSize = (filePath) => {
+    /* istanbul ignore next -- @preserve defensive: rollup always produces the declared output file */
+    try {
+        return statSync(filePath).size;
+    }
+    catch {
+        return 0;
+    }
+};
+/**
+ * Runs a single rollup invocation as described by `job` and writes the
+ * resulting report to `job.reportPath`.
+ *
+ * Use this to drive the worker logic in-process; use {@link dispatchRollupWorker}
+ * to run the same job in a forked Node process.
+ *
+ * @param job - Descriptor 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 runRollupWorkerJob({ format: 'esm', inputFile: '/abs/in.ts', ... })
+ * ```
+ */
+const runRollupWorkerJob = async (job) => {
+    const startedAt = Date.now();
+    ensureDir(job.outputDir);
+    ensureDir(dirname(job.reportPath));
+    const { config, outputs } = buildJob(job);
+    const bundle = await rollup(config);
+    let totalSize = 0;
+    try {
+        for (const output of outputs) {
+            await bundle.write(output);
+            totalSize += safeStatSize(output.file);
+        }
+    }
+    finally {
+        await bundle.close();
+    }
+    if (job.bin) {
+        chmodSync(job.bin.outputFile, job.bin.chmod);
+    }
+    const memory = process.memoryUsage();
+    const report = {
+        outputSize: totalSize,
+        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('rollup worker: missing job spec on argv\n');
+        process.exit(2);
+    }
+    const job = JSON.parse(raw);
+    runRollupWorkerJob(job).then(() => process.exit(0), (error) => {
+        const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+        process.stderr.write(`rollup worker for ${job.format}/${job.inputFile} failed: ${message}\n`);
+        process.exit(1);
+    });
+}
+
+export { dispatchRollupWorker, resolveDefaultRollupWorkerPath, runRollupWorkerJob, toBinBuildDescriptor, toCjsBuildDescriptor, toEsmBuildDescriptor, toIifeBuildDescriptor, toUmdBuildDescriptor };