@hyperfrontend/builder 0.1.0

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

@@ -0,0 +1,280 @@
+import { chmodSync, writeFileSync, mkdirSync, statSync } from 'node:fs';
+import { join as join$1, 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 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 { isBuiltin } from 'node:module';
+import { join } from '../../../_shared/bundle/fs/posix-path/index.esm.js';
+import { createExternalizeBundledDepsPlugin } from '../../../_shared/bundle/dependencies/externalize-plugin/index.esm.js';
+
+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 { runRollupWorkerJob };

package/bundle/rollup/worker/job-runner.d.ts

@@ -0,0 +1,18 @@
+import type { RollupBuildDescriptor, RollupWorkerReport } from './types';
+/**
+ * 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', ... })
+ * ```
+ */
+export declare const runRollupWorkerJob: (job: RollupBuildDescriptor) => Promise<RollupWorkerReport>;
+//# sourceMappingURL=job-runner.d.ts.map

package/bundle/rollup/worker/job-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-runner.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/rollup/worker/job-runner.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AA2OxE;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB,GAAU,KAAK,qBAAqB,KAAG,OAAO,CAAC,kBAAkB,CA2B/F,CAAA"}

package/bundle/rollup/worker/types.d.ts

@@ -0,0 +1,111 @@
+import type { WorkspaceBundledDepRoute } from '../../dependencies/externalize-plugin';
+/**
+ * Output format the rollup worker produces.
+ */
+export type RollupWorkerFormat = 'esm' | 'cjs' | 'iife' | 'umd';
+/**
+ * Externalize-bundled-deps plugin payload carried by ESM / CJS descriptors when
+ * a format opts into `bundleAllDeps`.
+ */
+export interface RollupWorkerBundledDepsPlugin {
+    /** Bundled-dep package names whose imports should be rewritten to `_dependencies/<dep>/`. */
+    deps: string[];
+    /** Absolute path to the `_dependencies/` root the plugin maps imports into. */
+    depsRoot: string;
+}
+/**
+ * Bundle-output configuration carried by IIFE / UMD descriptors.
+ *
+ * Captures the format-specific output knobs the worker needs to reconstruct
+ * `OutputOptions` for a self-contained browser bundle.
+ */
+export interface RollupWorkerBundleOutput {
+    /** Global variable name exposed by the bundle. */
+    globalName: string;
+    /** Emit a minified twin alongside the unminified bundle. */
+    minify: boolean;
+    /** Global names mapped onto the external dependencies. */
+    globals?: Record<string, string>;
+    /** UMD-only AMD module identifier. */
+    amdId?: string;
+}
+/**
+ * Bin-output configuration carried by ESM / CJS descriptors when the entry is a
+ * `package.json#bin` executable script.
+ *
+ * When set, the worker writes the bundle to {@link outputFile} (instead of the
+ * format's default `index.<fmt>.js` filename), prepends the {@link banner} and
+ * appends the {@link footer}, and applies {@link chmod} to the produced file so
+ * the npm bin symlink is invokable.
+ */
+export interface RollupWorkerBin {
+    /** Absolute path the worker writes the bin output to. */
+    outputFile: string;
+    /** Banner string prepended to the output (typically the `#!/usr/bin/env node` shebang). */
+    banner: string;
+    /** Footer string appended to the output (the bootstrap that wires the runner to `process.argv`). */
+    footer: string;
+    /** Rollup `output.exports` mode passed through to `bundle.write`. */
+    exports: 'named' | 'default' | 'auto' | 'none';
+    /** When `true`, dynamic imports are inlined so the bin remains a single self-contained file. */
+    inlineDynamicImports: boolean;
+    /** File mode applied via `chmodSync` after the output is written (e.g. `0o755`). */
+    chmod: number;
+}
+/**
+ * Serializable rollup-build descriptor: the contract between the parent
+ * orchestrator and a forked worker. Every field must round-trip through
+ * `JSON.stringify` / `JSON.parse` — no functions, no class instances.
+ *
+ * The worker reconstructs `RollupOptions` from the descriptor using the same
+ * plugin factories the parent would have used in-process.
+ */
+export interface RollupBuildDescriptor {
+    /** Output format. */
+    format: RollupWorkerFormat;
+    /** Absolute path to the source TS/JS entry. */
+    inputFile: string;
+    /** Absolute directory the worker writes its output(s) under. */
+    outputDir: string;
+    /** Pre-resolved external package list. */
+    external: string[];
+    /** Sourcemap toggle threaded into the rollup output. */
+    sourcemap: boolean;
+    /** When set: install the externalize-bundled-deps plugin (esm/cjs only). */
+    bundledDepsPlugin: RollupWorkerBundledDepsPlugin | null;
+    /**
+     * Workspace bundled-dep routes consumed by the externalize plugin. When non-empty,
+     * imports of these workspace packages (and matching sub-paths) are rerouted to
+     * the corresponding `_dependencies/<packageName>(/<sub>)?/index.<ext>` chunk.
+     * Empty array for descriptors that do not opt into workspace-dep hoisting.
+     */
+    workspaceRoutes: WorkspaceBundledDepRoute[];
+    /** Absolute tsconfig path threaded into the typescript plugin. */
+    tsConfigPath: string;
+    /** Absolute project root threaded into the typescript plugin. */
+    projectRoot: string;
+    /** Absolute workspace root threaded into the typescript plugin. */
+    workspaceRoot: string;
+    /** When `true`, workspace deps are inlined; otherwise treated as external. */
+    bundleWorkspaceDeps: boolean;
+    /** Bundle-output config carried by IIFE / UMD descriptors. `null` for esm/cjs. */
+    bundle: RollupWorkerBundleOutput | null;
+    /** Bin-output config carried by ESM / CJS descriptors that emit an executable bin. `null` for non-bin entries. */
+    bin: RollupWorkerBin | null;
+    /** Absolute path the worker writes its JSON report to. */
+    reportPath: string;
+}
+/**
+ * Memory + size summary written to `reportPath` when the worker exits cleanly.
+ */
+export interface RollupWorkerReport {
+    /** Total on-disk size of every emitted 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;
+}
+//# sourceMappingURL=types.d.ts.map

package/bundle/rollup/worker/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/rollup/worker/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAA;AAErF;;GAEG;AACH,MAAM,MAAM,kBAAkB,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,CAAA;AAE/D;;;GAGG;AACH,MAAM,WAAW,6BAA6B;IAC5C,6FAA6F;IAC7F,IAAI,EAAE,MAAM,EAAE,CAAA;IACd,+EAA+E;IAC/E,QAAQ,EAAE,MAAM,CAAA;CACjB;AAED;;;;;GAKG;AACH,MAAM,WAAW,wBAAwB;IACvC,kDAAkD;IAClD,UAAU,EAAE,MAAM,CAAA;IAClB,4DAA4D;IAC5D,MAAM,EAAE,OAAO,CAAA;IACf,0DAA0D;IAC1D,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,sCAAsC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,eAAe;IAC9B,yDAAyD;IACzD,UAAU,EAAE,MAAM,CAAA;IAClB,2FAA2F;IAC3F,MAAM,EAAE,MAAM,CAAA;IACd,oGAAoG;IACpG,MAAM,EAAE,MAAM,CAAA;IACd,qEAAqE;IACrE,OAAO,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,CAAA;IAC9C,gGAAgG;IAChG,oBAAoB,EAAE,OAAO,CAAA;IAC7B,oFAAoF;IACpF,KAAK,EAAE,MAAM,CAAA;CACd;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,qBAAqB;IACpC,qBAAqB;IACrB,MAAM,EAAE,kBAAkB,CAAA;IAC1B,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAA;IACjB,gEAAgE;IAChE,SAAS,EAAE,MAAM,CAAA;IACjB,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,wDAAwD;IACxD,SAAS,EAAE,OAAO,CAAA;IAClB,4EAA4E;IAC5E,iBAAiB,EAAE,6BAA6B,GAAG,IAAI,CAAA;IACvD;;;;;OAKG;IACH,eAAe,EAAE,wBAAwB,EAAE,CAAA;IAC3C,kEAAkE;IAClE,YAAY,EAAE,MAAM,CAAA;IACpB,iEAAiE;IACjE,WAAW,EAAE,MAAM,CAAA;IACnB,mEAAmE;IACnE,aAAa,EAAE,MAAM,CAAA;IACrB,8EAA8E;IAC9E,mBAAmB,EAAE,OAAO,CAAA;IAC5B,kFAAkF;IAClF,MAAM,EAAE,wBAAwB,GAAG,IAAI,CAAA;IACvC,kHAAkH;IAClH,GAAG,EAAE,eAAe,GAAG,IAAI,CAAA;IAC3B,0DAA0D;IAC1D,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,4DAA4D;IAC5D,UAAU,EAAE,MAAM,CAAA;IAClB,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAA;IACjB,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,CAAA;IAChB,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAA;CACnB"}

package/bundle/run-bundle-phase.d.ts

@@ -0,0 +1,23 @@
+import type { MemoryMonitor } from '../memory/monitor';
+import type { BuildConfig, BuildContext, FormatOutputs } from '../models';
+/**
+ * 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)
+ * ```
+ */
+export declare const runBundlePhase: (context: BuildContext, config: BuildConfig, monitor?: MemoryMonitor) => Promise<FormatOutputs>;
+//# sourceMappingURL=run-bundle-phase.d.ts.map

package/bundle/run-bundle-phase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-bundle-phase.d.ts","sourceRoot":"","sources":["../../../../../../../libs/builder/src/bundle/run-bundle-phase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAwB,aAAa,EAA8C,MAAM,WAAW,CAAA;AA4P3I;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,GAAU,SAAS,YAAY,EAAE,QAAQ,WAAW,EAAE,UAAU,aAAa,KAAG,OAAO,CAAC,aAAa,CA8D/H,CAAA"}

package/clean-output.d.ts

@@ -0,0 +1,26 @@
+import type { BuildContext } from './models';
+/**
+ * Empties a build's own output directory before emission so a build never
+ * inherits stale artifacts from a previous run — e.g. a `*.js.map` left behind
+ * after sourcemaps were turned off, or a chunk for a since-renamed entry.
+ *
+ * Scoped and guarded: only the *target project's own* directory is removed
+ * (e.g. `dist/libs/<project>`), never the shared `dist/` root or anything above
+ * it. The path is refused unless it lies strictly inside the workspace and is
+ * not the bare `dist/` root, so a misconfigured `outputPath` that collapsed to
+ * the workspace root, an ancestor, `/`, or `<workspaceRoot>/dist` can never
+ * remove the repository or every library's output at once. A non-existent
+ * directory is a no-op.
+ *
+ * @param context - Resolved build context supplying `outputPath` and `workspaceRoot`.
+ * @throws {Error} When `outputPath` is the workspace root, an ancestor of it,
+ * outside the workspace, or the bare `dist/` root — anything broader than a
+ * single project's output directory.
+ *
+ * @example Cleaning a library's output before the bundle phase
+ * ```typescript
+ * cleanOutputPath(context) // removes dist/libs/<project>, leaves the rest of dist/ intact
+ * ```
+ */
+export declare const cleanOutputPath: (context: BuildContext) => void;
+//# sourceMappingURL=clean-output.d.ts.map

package/clean-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clean-output.d.ts","sourceRoot":"","sources":["../../../../../../libs/builder/src/clean-output.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAI5C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,YAAY,KAAG,IAUvD,CAAA"}