@hyperfrontend/builder 0.1.0 → 0.1.1

package/bin/script/index.esm.js

@@ -3,13 +3,13 @@ import { logger } from '../../_dependencies/@hyperfrontend/logging/index.esm.js'
 import { join, ensureDir } from '../../_dependencies/@hyperfrontend/project-scope/core/index.esm.js';
 import { join as join$1, getDirname } from '../../_dependencies/@hyperfrontend/project-scope/core/path/index.esm.js';
 import 'node:module';
-import 'node:path';
+import { dirname, join as join$2 } from 'node:path';
 import { isArray } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.esm.js';
 import '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.esm.js';
 import '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/set/index.esm.js';
 import '../../_dependencies/@hyperfrontend/project-scope/core/fs/index.esm.js';
 import { spawn } from 'node:child_process';
-import { rmSync, existsSync, mkdtempSync, readFileSync } from 'node:fs';
+import { existsSync, rmSync, mkdtempSync, readFileSync } 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';
@@ -82,45 +82,91 @@ const toBinBuildDescriptor = (bin, context, format, formats, 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(workspaceRoot, 'node_modules', '@swc-node', 'register', 'index.js'));
+const probeDir = (dir, offset) => {
+    const compiled = join$2(dir, ...offset, 'index.cjs.js');
+    if (existsSync(compiled))
+        return { path: compiled, execArgv: [] };
+    const source = join$2(dir, ...offset, 'index.ts');
+    if (existsSync(source))
+        return { path: source, execArgv: ['--require', SWC_NODE_REGISTER] };
+    return undefined;
+};
 /**
- * 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).
+ * Directory of the currently-executing builder module, read from `__dirname`.
+ * It is present in the shipped CommonJS build, in the `@swc-node/register` source
+ * bootstrap, and under the test runner, so callers get their own on-disk location
+ * and can find the worker beside them however the builder was packaged.
  *
- * 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`)
+ * @returns Absolute directory path of the running module.
  *
- * @param workspaceRoot - Absolute workspace root.
- * @returns Worker invocation descriptor, or `undefined` if no candidate exists.
- *
- * @example Locating the worker for an in-workspace consumer
+ * @example Anchoring a lookup beside the running builder
  * ```typescript
- * const invocation = resolveDefaultRollupWorkerPath('/abs/repo')
- * if (!invocation) throw new Error('builder rollup worker artifact not found')
+ * const invocation = ascendForWorker(['bundle', 'rollup', 'worker'], currentModuleDir())
  * ```
  */
-const resolveDefaultRollupWorkerPath = (workspaceRoot) => {
-    const distCandidates = [
-        join(workspaceRoot, 'dist', 'libs', 'builder', 'bundle', 'rollup', 'worker', 'index.cjs.js'),
-        join(workspaceRoot, 'node_modules', '@hyperfrontend', 'builder', 'bundle', 'rollup', 'worker', 'index.cjs.js'),
-    ];
-    for (const path of distCandidates) {
-        if (existsSync(path))
-            return { path, execArgv: [] };
+const currentModuleDir = () => {
+    /* istanbul ignore if -- @preserve the ESM build has no __dirname; the shipped CommonJS build and the test runner always define it, so this guard is unreachable under test */
+    if (typeof __dirname === 'undefined') {
+        throw createError('@hyperfrontend/builder self-location requires the CommonJS build; drive build() from the CommonJS entry point');
     }
-    const sourcePath = join(workspaceRoot, 'libs', 'builder', 'src', 'bundle', 'rollup', 'worker', 'index.ts');
-    if (existsSync(sourcePath) && swcNodeAvailable(workspaceRoot)) {
-        return { path: sourcePath, execArgv: ['--require', SWC_NODE_REGISTER] };
+    return __dirname;
+};
+/**
+ * Locate a builder worker entry by ascending from a start directory toward the
+ * filesystem root, returning the first ancestor at which the worker exists at the
+ * given in-package offset. The compiled `index.cjs.js` is preferred; an `index.ts`
+ * sibling (source-mode bootstrap) resolves with the swc loader attached.
+ *
+ * The worker ships inside the builder's own package, so resolving relative to the
+ * running module finds it wherever the package lives — built dist, an installed
+ * `node_modules` copy, or melded into a host bundle under `_dependencies/`.
+ *
+ * @param offset - In-package path segments to the worker directory (e.g. `['bundle', 'rollup', 'worker']`).
+ * @param startDir - Directory to begin the ascent from. Defaults to the running module's directory; pass an explicit value to resolve from another anchor or under test.
+ * @returns The resolved worker invocation, or `undefined` if no worker exists at the offset under any ancestor.
+ *
+ * @example Resolving the rollup worker from the running module
+ * ```typescript
+ * const invocation = ascendForWorker(['bundle', 'rollup', 'worker'])
+ * if (!invocation) throw new Error('builder rollup worker not found beside the builder module')
+ * ```
+ */
+const ascendForWorker = (offset, startDir = currentModuleDir()) => {
+    let dir = startDir;
+    let parent = dirname(dir);
+    // how: probe each level then step up; the final probe covers the filesystem root, where parent === dir
+    while (parent !== dir) {
+        const found = probeDir(dir, offset);
+        if (found)
+            return found;
+        dir = parent;
+        parent = dirname(dir);
     }
-    return undefined;
+    return probeDir(dir, offset);
 };
+
+const log$1 = logger.channel('builder:bundle:rollup:dispatch');
+const REPORT_DIR_PREFIX = 'hf-builder-rollup-';
+/**
+ * Resolves the rollup worker by self-locating it beside the running builder
+ * module: ascends from the module's own directory to the builder package root
+ * and returns the worker at `bundle/rollup/worker`. This works whether the
+ * builder runs from its built dist, an installed `node_modules` copy, or melded
+ * into a host bundle under `_dependencies/`. The compiled `index.cjs.js` is
+ * preferred; an `index.ts` sibling resolves with the `@swc-node/register` loader
+ * for source-mode bootstrap.
+ *
+ * @param startDir - Directory to begin the ascent from. Defaults to the running module's directory; pass an explicit value to resolve from another anchor or under test.
+ * @returns Worker invocation descriptor, or `undefined` if no worker is found under any ancestor.
+ *
+ * @example Locating the worker beside the builder
+ * ```typescript
+ * const invocation = resolveDefaultRollupWorkerPath()
+ * if (!invocation) throw new Error('builder rollup worker artifact not found')
+ * ```
+ */
+const resolveDefaultRollupWorkerPath = (startDir) => ascendForWorker(['bundle', 'rollup', 'worker'], startDir);
 const createReportDir = () => mkdtempSync(join(tmpdir(), REPORT_DIR_PREFIX));
 const reportPathFor = (reportDir, descriptor) => {
     const safeLabel = descriptor.inputFile.replace(/[^a-zA-Z0-9_-]+/g, '_');
@@ -200,10 +246,10 @@ const dispatchRollupWorker = async (descriptor, options) => {
 };
 
 const log = logger.channel('builder:bin:script');
-const resolveWorkerOrThrow = (workspaceRoot) => {
-    const invocation = resolveDefaultRollupWorkerPath(workspaceRoot);
+const resolveWorkerOrThrow = () => {
+    const invocation = resolveDefaultRollupWorkerPath();
     if (!invocation) {
-        throw createError('rollup worker could not be resolved for bin script bundling. Build @hyperfrontend/builder at least once before invoking the bin phase, or ensure @swc-node/register is installed for source-mode bootstrap.');
+        throw createError('rollup worker could not be located beside the builder module for bin script bundling. The @hyperfrontend/builder package appears incomplete, or @swc-node/register is missing for source-mode bootstrap.');
     }
     return invocation;
 };
@@ -244,7 +290,7 @@ const buildJsBin = async (bin, ctx) => {
     const formats = normalizeFormats(bin.format);
     const binDir = join(ctx.outputPath, 'bin');
     ensureDir(binDir);
-    const worker = resolveWorkerOrThrow(ctx.workspaceRoot);
+    const worker = resolveWorkerOrThrow();
     const outputs = [];
     for (const format of formats) {
         const descriptor = toBinBuildDescriptor(bin, ctx, format, formats, '');

package/bundle/declarations/dts-per-entry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dts-per-entry.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/declarations/dts-per-entry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,YAAY,EAAc,MAAM,cAAc,CAAA;AAqD5D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,cAAc,GAAU,SAAS,YAAY,EAAE,UAAU,aAAa,KAAG,OAAO,CAAC,IAAI,CAejG,CAAA"}
+{"version":3,"file":"dts-per-entry.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/declarations/dts-per-entry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,YAAY,EAAc,MAAM,cAAc,CAAA;AAqD5D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,cAAc,GAAU,SAAS,YAAY,EAAE,UAAU,aAAa,KAAG,OAAO,CAAC,IAAI,CAiBjG,CAAA"}

package/bundle/declarations/dts-pre-pass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dts-pre-pass.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/declarations/dts-pre-pass.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,YAAY,EAAuB,MAAM,cAAc,CAAA;AA8ErE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa,GAAU,SAAS,YAAY,EAAE,UAAU,aAAa,KAAG,OAAO,CAAC,IAAI,CAiBhG,CAAA"}
+{"version":3,"file":"dts-pre-pass.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/declarations/dts-pre-pass.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,YAAY,EAAuB,MAAM,cAAc,CAAA;AA8ErE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,aAAa,GAAU,SAAS,YAAY,EAAE,UAAU,aAAa,KAAG,OAAO,CAAC,IAAI,CAmBhG,CAAA"}

package/bundle/declarations/index.cjs.js

@@ -1,8 +1,8 @@
 'use strict';
 
-const index_cjs_js$6 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.cjs.js');
-const index_cjs_js$2 = require('../../_dependencies/@hyperfrontend/logging/index.cjs.js');
-const index_cjs_js$3 = require('../../_dependencies/@hyperfrontend/project-scope/core/index.cjs.js');
+const index_cjs_js$2 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.cjs.js');
+const index_cjs_js$3 = require('../../_dependencies/@hyperfrontend/logging/index.cjs.js');
+const index_cjs_js$4 = require('../../_dependencies/@hyperfrontend/project-scope/core/index.cjs.js');
 const index_cjs_js$1 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.cjs.js');
 const index_cjs_js = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/set/index.cjs.js');
 const node_module = require('node:module');
@@ -10,8 +10,8 @@ const node_path = require('node:path');
 const node_child_process = require('node:child_process');
 const node_fs = require('node:fs');
 const node_os = require('node:os');
-const index_cjs_js$5 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/json/index.cjs.js');
-const index_cjs_js$4 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/promise/index.cjs.js');
+const index_cjs_js$6 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/json/index.cjs.js');
+const index_cjs_js$5 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/promise/index.cjs.js');
 const index_cjs_js$7 = require('../../_dependencies/@hyperfrontend/project-scope/core/fs/index.cjs.js');
 const index_cjs_js$8 = require('../../_dependencies/@hyperfrontend/project-scope/core/path/index.cjs.js');
 const index_cjs_js$9 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/date/index.cjs.js');
@@ -25,13 +25,77 @@ const { collectChunkSpecifiers, hasDynamicSpecifier } = require('../../_shared/b
 const { entryDirOf } = require('../../_shared/bundle/fs/entry-dir/index.cjs.js');
 const { isUnderDir } = require('../../_shared/bundle/fs/under-dir/index.cjs.js');
 
-const log$4 = index_cjs_js$2.logger.channel('builder:bundle:dependencies:pre-pass');
+const SWC_NODE_REGISTER = '@swc-node/register';
+const probeDir = (dir, offset) => {
+    const compiled = node_path.join(dir, ...offset, 'index.cjs.js');
+    if (node_fs.existsSync(compiled))
+        return { path: compiled, execArgv: [] };
+    const source = node_path.join(dir, ...offset, 'index.ts');
+    if (node_fs.existsSync(source))
+        return { path: source, execArgv: ['--require', SWC_NODE_REGISTER] };
+    return undefined;
+};
+/**
+ * Directory of the currently-executing builder module, read from `__dirname`.
+ * It is present in the shipped CommonJS build, in the `@swc-node/register` source
+ * bootstrap, and under the test runner, so callers get their own on-disk location
+ * and can find the worker beside them however the builder was packaged.
+ *
+ * @returns Absolute directory path of the running module.
+ *
+ * @example Anchoring a lookup beside the running builder
+ * ```typescript
+ * const invocation = ascendForWorker(['bundle', 'rollup', 'worker'], currentModuleDir())
+ * ```
+ */
+const currentModuleDir = () => {
+    /* istanbul ignore if -- @preserve the ESM build has no __dirname; the shipped CommonJS build and the test runner always define it, so this guard is unreachable under test */
+    if (typeof __dirname === 'undefined') {
+        throw index_cjs_js$2.createError('@hyperfrontend/builder self-location requires the CommonJS build; drive build() from the CommonJS entry point');
+    }
+    return __dirname;
+};
+/**
+ * Locate a builder worker entry by ascending from a start directory toward the
+ * filesystem root, returning the first ancestor at which the worker exists at the
+ * given in-package offset. The compiled `index.cjs.js` is preferred; an `index.ts`
+ * sibling (source-mode bootstrap) resolves with the swc loader attached.
+ *
+ * The worker ships inside the builder's own package, so resolving relative to the
+ * running module finds it wherever the package lives — built dist, an installed
+ * `node_modules` copy, or melded into a host bundle under `_dependencies/`.
+ *
+ * @param offset - In-package path segments to the worker directory (e.g. `['bundle', 'rollup', 'worker']`).
+ * @param startDir - Directory to begin the ascent from. Defaults to the running module's directory; pass an explicit value to resolve from another anchor or under test.
+ * @returns The resolved worker invocation, or `undefined` if no worker exists at the offset under any ancestor.
+ *
+ * @example Resolving the rollup worker from the running module
+ * ```typescript
+ * const invocation = ascendForWorker(['bundle', 'rollup', 'worker'])
+ * if (!invocation) throw new Error('builder rollup worker not found beside the builder module')
+ * ```
+ */
+const ascendForWorker = (offset, startDir = currentModuleDir()) => {
+    let dir = startDir;
+    let parent = node_path.dirname(dir);
+    // how: probe each level then step up; the final probe covers the filesystem root, where parent === dir
+    while (parent !== dir) {
+        const found = probeDir(dir, offset);
+        if (found)
+            return found;
+        dir = parent;
+        parent = node_path.dirname(dir);
+    }
+    return probeDir(dir, offset);
+};
+
+const log$4 = index_cjs_js$3.logger.channel('builder:bundle:dependencies:pre-pass');
 const REPORT_DIR_PREFIX = 'hf-builder-prepass-';
-const createReportDir = () => node_fs.mkdtempSync(index_cjs_js$3.join(node_os.tmpdir(), REPORT_DIR_PREFIX));
-const reportPathFor = (reportDir, job, index) => index_cjs_js$3.join(reportDir, `${index}-${job.dep.replace(/\//g, '__')}-${job.kind}-${job.format}.json`);
-const runOne = (job, reportPath, options) => index_cjs_js$4.createPromise((resolve, reject) => {
+const createReportDir = () => node_fs.mkdtempSync(index_cjs_js$4.join(node_os.tmpdir(), REPORT_DIR_PREFIX));
+const reportPathFor = (reportDir, job, index) => index_cjs_js$4.join(reportDir, `${index}-${job.dep.replace(/\//g, '__')}-${job.kind}-${job.format}.json`);
+const runOne = (job, reportPath, options) => index_cjs_js$5.createPromise((resolve, reject) => {
     const execPath = options.execPath ?? process.execPath;
-    const argv = [...(options.execArgv ?? []), options.workerPath, index_cjs_js$5.stringify({ ...job, reportPath })];
+    const argv = [...(options.execArgv ?? []), options.workerPath, index_cjs_js$6.stringify({ ...job, reportPath })];
     const child = node_child_process.spawn(execPath, argv, { stdio: ['ignore', 'pipe', 'pipe'] });
     let capturedStderr = '';
     child.stdout?.on('data', (chunk) => {
@@ -43,12 +107,12 @@ const runOne = (job, reportPath, options) => index_cjs_js$4.createPromise((resol
         process.stderr.write(text);
     });
     child.on('error', (error) => {
-        reject(index_cjs_js$6.createError(`pre-pass worker for ${job.dep} (${job.kind}/${job.format}) failed to spawn: ${error.message}`));
+        reject(index_cjs_js$2.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(index_cjs_js$6.createError(`pre-pass worker for ${job.dep} (${job.kind}/${job.format}) exited with code ${code}\n${tail}`));
+            reject(index_cjs_js$2.createError(`pre-pass worker for ${job.dep} (${job.kind}/${job.format}) exited with code ${code}\n${tail}`));
             return;
         }
         resolve();
@@ -56,48 +120,30 @@ const runOne = (job, reportPath, options) => index_cjs_js$4.createPromise((resol
 });
 const readReport = (reportPath, job) => {
     if (!node_fs.existsSync(reportPath)) {
-        throw index_cjs_js$6.createError(`pre-pass worker for ${job.dep} (${job.kind}/${job.format}) did not write a report at ${reportPath}`);
+        throw index_cjs_js$2.createError(`pre-pass worker for ${job.dep} (${job.kind}/${job.format}) did not write a report at ${reportPath}`);
     }
-    const data = index_cjs_js$5.parse(node_fs.readFileSync(reportPath, 'utf8'));
+    const data = index_cjs_js$6.parse(node_fs.readFileSync(reportPath, 'utf8'));
     return { job, outputSize: data.outputSize, endHeapMB: data.endHeapMB, endRssMB: data.endRssMB, durationMs: data.durationMs };
 };
-const SWC_NODE_REGISTER = '@swc-node/register';
-const swcNodeAvailable = (workspaceRoot) => node_fs.existsSync(index_cjs_js$3.join(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
+ * Resolves the dependency pre-pass worker by self-locating it beside the running
+ * builder module: ascends from the module's own directory to the builder package
+ * root and returns the worker at `bundle/dependencies/worker`. This works whether
+ * the builder runs from its built dist, an installed `node_modules` copy, or
+ * melded into a host bundle under `_dependencies/`. The compiled `index.cjs.js`
+ * is preferred; an `index.ts` sibling resolves with the `@swc-node/register`
+ * loader for source-mode bootstrap.
+ *
+ * @param startDir - Directory to begin the ascent from. Defaults to the running module's directory; pass an explicit value to resolve from another anchor or under test.
+ * @returns Worker invocation descriptor, or `undefined` if no worker is found under any ancestor.
+ *
+ * @example Locating the worker beside the builder
  * ```typescript
- * const invocation = resolveDefaultWorkerPath('/abs/repo')
+ * const invocation = resolveDefaultWorkerPath()
  * if (!invocation) throw new Error('builder worker artifact not found')
  * ```
  */
-const resolveDefaultWorkerPath = (workspaceRoot) => {
-    const distCandidates = [
-        index_cjs_js$3.join(workspaceRoot, 'dist', 'libs', 'builder', 'bundle', 'dependencies', 'worker', 'index.cjs.js'),
-        index_cjs_js$3.join(workspaceRoot, 'node_modules', '@hyperfrontend', 'builder', 'bundle', 'dependencies', 'worker', 'index.cjs.js'),
-    ];
-    for (const path of distCandidates) {
-        if (node_fs.existsSync(path))
-            return { path, execArgv: [] };
-    }
-    const sourcePath = index_cjs_js$3.join(workspaceRoot, 'libs', 'builder', 'src', 'bundle', 'dependencies', 'worker', 'index.ts');
-    if (node_fs.existsSync(sourcePath) && swcNodeAvailable(workspaceRoot)) {
-        return { path: sourcePath, execArgv: ['--require', SWC_NODE_REGISTER] };
-    }
-    return undefined;
-};
+const resolveDefaultWorkerPath = (startDir) => ascendForWorker(['bundle', 'dependencies', 'worker'], startDir);
 /**
  * Sequentially runs the supplied pre-pass jobs by forking a fresh Node child
  * per invocation. Strict sequential execution is mandatory — concurrent
@@ -335,14 +381,14 @@ const filterSiblings = (srcPath, entries) => entries.filter((entry) => entry.src
  */
 const dtsPathFor = (outputPath, srcPath) => srcPath ? join(outputPath, srcPath, 'index.d.ts') : join(outputPath, 'index.d.ts');
 
-const log$3 = index_cjs_js$2.logger.channel('builder:bundle:declarations:dts-per-entry');
+const log$3 = index_cjs_js$3.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 (!index_cjs_js$3.exists(indexDtsPath))
+        if (!index_cjs_js$4.exists(indexDtsPath))
             continue;
         descriptors.push({ srcPath: entry.srcPath, indexDtsPath });
     }
@@ -356,7 +402,7 @@ const buildJobs$1 = (entries, context) => {
     const depsRoot = depsRootOf(context);
     for (const entry of entries) {
         const inputPath = dtsPathFor(context.outputPath, entry.srcPath);
-        if (!index_cjs_js$3.exists(inputPath))
+        if (!index_cjs_js$4.exists(inputPath))
             continue;
         const siblingEntries = buildSiblingDescriptors(entries, context, entry.srcPath);
         jobs.push({
@@ -403,9 +449,9 @@ const buildJobs$1 = (entries, context) => {
 const runDtsPerEntry = async (context, monitor) => {
     if (context.bundledDeps.length === 0 && context.workspaceBundledDeps.length === 0)
         return;
-    const invocation = resolveDefaultWorkerPath(context.workspaceRoot);
+    const invocation = resolveDefaultWorkerPath();
     if (!invocation) {
-        throw index_cjs_js$6.createError('bundleAllDeps is enabled but the pre-pass worker artifact was not found for the per-entry d.ts pass.');
+        throw index_cjs_js$2.createError('bundleAllDeps is enabled but the pre-pass worker could not be located beside the builder module for the per-entry d.ts pass.');
     }
     const jobs = buildJobs$1(context.entryPointDiscovery.entryPoints, context);
     if (jobs.length === 0) {
@@ -498,17 +544,17 @@ const resolveDepEntry = (options) => {
     const { dep, projectRoot, workspaceRoot} = options;
     const pkgPath = findPackageJsonViaRequire(dep, ROOTS(projectRoot, workspaceRoot));
     if (!pkgPath)
-        throw index_cjs_js$6.createError(`pre-pass: cannot locate package.json for dep "${dep}"`);
+        throw index_cjs_js$2.createError(`pre-pass: cannot locate package.json for dep "${dep}"`);
     const pkg = index_cjs_js$7.readJsonFileIfExists(pkgPath);
     if (!pkg)
-        throw index_cjs_js$6.createError(`pre-pass: package.json for dep "${dep}" could not be read at ${pkgPath}`);
+        throw index_cjs_js$2.createError(`pre-pass: package.json for dep "${dep}" could not be read at ${pkgPath}`);
     const relative = ensureDtsEntry(pkg);
     if (!relative)
-        throw index_cjs_js$6.createError(`pre-pass: dep "${dep}" has no ${'types/typings'} entry`);
+        throw index_cjs_js$2.createError(`pre-pass: dep "${dep}" has no ${'types/typings'} entry`);
     return absolutize(node_path.dirname(pkgPath), relative);
 };
 
-const log$2 = index_cjs_js$2.logger.channel('builder:bundle:declarations:dts-pre-pass');
+const log$2 = index_cjs_js$3.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 = (entry, all) => all.filter((other) => (entry.policy === 'sub-path' ? other.specifier !== entry.specifier : other.packageName !== entry.packageName));
 const buildJobs = (deps, context) => {
@@ -532,7 +578,7 @@ const buildJobs = (deps, context) => {
             dep,
             inputPath,
             format: 'esm',
-            outputPath: index_cjs_js$3.join(depsRoot, dep, 'index.d.ts'),
+            outputPath: index_cjs_js$4.join(depsRoot, dep, 'index.d.ts'),
             otherDeps: [...otherNpmDeps, ...workspacePrefixDeps],
             otherWorkspaceSpecifiers: workspaceExactSpecifiers,
             npmDeps: otherNpmDeps,
@@ -558,7 +604,7 @@ const buildWorkspaceJobs = (context, npmDeps) => {
             dep: entry.specifier,
             inputPath: entry.inputPath,
             format: 'esm',
-            outputPath: index_cjs_js$3.join(depsRoot, workspaceDtsOutputFile(entry)),
+            outputPath: index_cjs_js$4.join(depsRoot, workspaceDtsOutputFile(entry)),
             otherDeps: [...npmDeps, ...otherWorkspacePackages],
             otherWorkspaceSpecifiers: otherSubPathSpecifiers,
             tsConfigPath: entry.tsConfigPath,
@@ -587,9 +633,9 @@ const buildWorkspaceJobs = (context, npmDeps) => {
 const runDtsPrePass = async (context, monitor) => {
     if (context.bundledDeps.length === 0 && context.workspaceBundledDeps.length === 0)
         return;
-    const invocation = resolveDefaultWorkerPath(context.workspaceRoot);
+    const invocation = resolveDefaultWorkerPath();
     if (!invocation) {
-        throw index_cjs_js$6.createError('bundleAllDeps is enabled but the pre-pass worker artifact was not found for the d.ts pre-pass.');
+        throw index_cjs_js$2.createError('bundleAllDeps is enabled but the pre-pass worker could not be located beside the builder module for the d.ts pre-pass.');
     }
     const npmJobs = buildJobs(context.bundledDeps, context);
     const workspaceJobs = buildWorkspaceJobs(context, context.bundledDeps);
@@ -604,7 +650,7 @@ const runDtsPrePass = async (context, monitor) => {
     monitor?.check('bundle:declarations:dts-prepass:end');
 };
 
-const log$1 = index_cjs_js$2.logger.channel('builder:bundle:declarations');
+const log$1 = index_cjs_js$3.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);
@@ -613,7 +659,7 @@ const startHeartbeat = (label, startedAt) => index_cjs_js$a.setInterval(() => {
     const elapsedSec = ((index_cjs_js$9.dateNow() - startedAt) / 1000).toFixed(1);
     log$1.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) => index_cjs_js$4.createPromise((resolve, reject) => {
+const runTsc = (tscPath, args, cwd) => index_cjs_js$5.createPromise((resolve, reject) => {
     const startedAt = index_cjs_js$9.dateNow();
     const child = node_child_process.spawn(tscPath, args, { cwd, stdio: ['ignore', 'pipe', 'pipe'] });
     log$1.info(`tsc spawned: pid=${child.pid ?? 'unknown'}`);
@@ -641,7 +687,7 @@ const runTsc = (tscPath, args, cwd) => index_cjs_js$4.createPromise((resolve, re
         const durationMs = index_cjs_js$9.dateNow() - startedAt;
         if (code !== 0) {
             log$1.error(`tsc failed with exit code ${code} after ${durationMs}ms`);
-            reject(index_cjs_js$6.createError(`tsc failed with exit code ${code}`));
+            reject(index_cjs_js$2.createError(`tsc failed with exit code ${code}`));
             return;
         }
         log$1.info(`tsc exited 0 in ${durationMs}ms`);
@@ -691,7 +737,7 @@ const generateDeclarations = async (context) => {
     return result;
 };
 
-const log = index_cjs_js$2.logger.channel('builder:bundle:declarations:prune-orphans');
+const log = index_cjs_js$3.logger.channel('builder:bundle:declarations:prune-orphans');
 const ORPHAN_DTS_RE = /\.d\.ts$|\.d\.ts\.map$/;
 const INDEX_DTS_NAME = 'index.d.ts';
 /**
@@ -712,13 +758,13 @@ const INDEX_DTS_NAME = 'index.d.ts';
  * @returns Absolute `.d.ts` path of the referenced sibling, or `null`.
  */
 const toDtsTarget = (dir, spec, depsRoot) => {
-    const abs = index_cjs_js$3.join(dir, spec);
+    const abs = index_cjs_js$4.join(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`, index_cjs_js$3.join(abs, INDEX_DTS_NAME)];
+    const candidates = spec.endsWith('.js') ? [`${abs.slice(0, -3)}.d.ts`] : [`${abs}.d.ts`, index_cjs_js$4.join(abs, INDEX_DTS_NAME)];
     for (const candidate of candidates) {
         if (isUnderDir(candidate, depsRoot))
             return null;
-        if (index_cjs_js$3.exists(candidate))
+        if (index_cjs_js$4.exists(candidate))
             return candidate;
     }
     return null;
@@ -746,7 +792,7 @@ const computeReachableDeclarations = (roots, depsRoot) => {
     const reachable = index_cjs_js.createSet([]);
     const queue = [];
     for (const root of roots) {
-        if (index_cjs_js$3.exists(root) && !reachable.has(root)) {
+        if (index_cjs_js$4.exists(root) && !reachable.has(root)) {
             reachable.add(root);
             queue.push(root);
         }
@@ -756,12 +802,12 @@ const computeReachableDeclarations = (roots, depsRoot) => {
         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 = index_cjs_js$3.readFileContent(file);
+        const source = index_cjs_js$4.readFileContent(file);
         if (hasDynamicSpecifier(source)) {
             log.warn(`dynamic import/require in ${file}; keeping all orphan declarations for safety`);
             return null;
         }
-        const dir = index_cjs_js$3.getDirname(file);
+        const dir = index_cjs_js$4.getDirname(file);
         for (const spec of collectChunkSpecifiers(source)) {
             const target = toDtsTarget(dir, spec, depsRoot);
             if (target !== null && !reachable.has(target)) {
@@ -783,10 +829,10 @@ const computeReachableDeclarations = (roots, depsRoot) => {
  */
 const collectDeclarationFiles = (root, depsRoot) => {
     const files = [];
-    if (!index_cjs_js$3.exists(root))
+    if (!index_cjs_js$4.exists(root))
         return files;
     const visit = (dir) => {
-        for (const entry of index_cjs_js$3.readDirectory(dir)) {
+        for (const entry of index_cjs_js$4.readDirectory(dir)) {
             if (entry.isDirectory) {
                 if (isUnderDir(entry.path, depsRoot))
                     continue;
@@ -837,7 +883,7 @@ const pruneOrphanDeclarations = (context) => {
         const dir = entryDirOf(entry, context);
         if (isUnderDir(dir, depsRoot))
             continue;
-        roots.push(index_cjs_js$3.join(dir, INDEX_DTS_NAME));
+        roots.push(index_cjs_js$4.join(dir, INDEX_DTS_NAME));
     }
     const reachable = computeReachableDeclarations(roots, depsRoot);
     if (reachable === null)