@hyperfrontend/builder 0.1.0 → 0.1.1

package/bundle/index.esm.js

@@ -8,7 +8,7 @@ import { setTimeout, clearInterval, setInterval } from '../_dependencies/@hyperf
 import { createRequire } from 'node:module';
 import { join as join$1, dirname, isAbsolute, resolve } from 'node:path';
 import { spawn } from 'node:child_process';
-import { rmSync, existsSync, mkdtempSync, readFileSync, cpSync, statSync, unlinkSync, rmdirSync } from 'node:fs';
+import { existsSync, rmSync, mkdtempSync, readFileSync, cpSync, statSync, unlinkSync, rmdirSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { stringify, parse } from '../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/json/index.esm.js';
 import { readJsonFileIfExists, exists as exists$1, readJsonFile } from '../_dependencies/@hyperfrontend/project-scope/core/fs/index.esm.js';
@@ -33,6 +33,70 @@ import { removeEmptyDirs } from '../_shared/bundle/fs/empty-dirs/index.esm.js';
 import { mergeDemand, classifyNamespaceUse, collectNamespaceUsage } from '../_shared/bundle/dependencies/prune/namespace-usage/index.esm.js';
 import { resolveEntries } from '../_shared/bundle/entries/resolve-entries/index.esm.js';
 
+const SWC_NODE_REGISTER = '@swc-node/register';
+const probeDir = (dir, offset) => {
+    const compiled = join$1(dir, ...offset, 'index.cjs.js');
+    if (existsSync(compiled))
+        return { path: compiled, execArgv: [] };
+    const source = join$1(dir, ...offset, 'index.ts');
+    if (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 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 = 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 probeDir(dir, offset);
+};
+
 const log$b = logger.channel('builder:bundle:dependencies:pre-pass');
 const REPORT_DIR_PREFIX$1 = 'hf-builder-prepass-';
 const createReportDir$1 = () => mkdtempSync(join$2(tmpdir(), REPORT_DIR_PREFIX$1));
@@ -69,43 +133,25 @@ const readReport$1 = (reportPath, job) => {
     const data = parse(readFileSync(reportPath, 'utf8'));
     return { job, outputSize: data.outputSize, endHeapMB: data.endHeapMB, endRssMB: data.endRssMB, durationMs: data.durationMs };
 };
-const SWC_NODE_REGISTER$1 = '@swc-node/register';
-const swcNodeAvailable$1 = (workspaceRoot) => existsSync(join$2(workspaceRoot, 'node_modules', '@swc-node', 'register', 'index.js'));
 /**
- * Default worker-path resolution: prefers the built-and-published artifact, falls
- * back to the workspace dist path, and finally to the in-source TypeScript file
- * via `@swc-node/register` (bootstrap case where builder is building itself for
- * the first time and the dist worker doesn't exist yet).
- *
- * Looks at, in order:
- * 1. `<workspaceRoot>/dist/libs/builder/bundle/dependencies/worker/index.cjs.js`
- * 2. `<workspaceRoot>/node_modules/@hyperfrontend/builder/bundle/dependencies/worker/index.cjs.js`
- * 3. `<workspaceRoot>/libs/builder/src/bundle/dependencies/worker/index.ts` (with `--require \@swc-node/register`)
- *
- * @param workspaceRoot - Absolute workspace root.
- * @returns Worker invocation descriptor, or `undefined` if no candidate exists.
- *
- * @example Locating the worker for an in-workspace consumer
+ * 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 = [
-        join$2(workspaceRoot, 'dist', 'libs', 'builder', 'bundle', 'dependencies', 'worker', 'index.cjs.js'),
-        join$2(workspaceRoot, 'node_modules', '@hyperfrontend', 'builder', 'bundle', 'dependencies', 'worker', 'index.cjs.js'),
-    ];
-    for (const path of distCandidates) {
-        if (existsSync(path))
-            return { path, execArgv: [] };
-    }
-    const sourcePath = join$2(workspaceRoot, 'libs', 'builder', 'src', 'bundle', 'dependencies', 'worker', 'index.ts');
-    if (existsSync(sourcePath) && swcNodeAvailable$1(workspaceRoot)) {
-        return { path: sourcePath, execArgv: ['--require', SWC_NODE_REGISTER$1] };
-    }
-    return undefined;
-};
+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
@@ -234,9 +280,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 createError('bundleAllDeps is enabled but the pre-pass worker artifact was not found for the per-entry d.ts pass.');
+        throw 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) {
@@ -419,9 +465,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 createError('bundleAllDeps is enabled but the pre-pass worker artifact was not found for the d.ts pre-pass.');
+        throw 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);
@@ -3339,43 +3385,25 @@ const toUmdBuildDescriptor = (entry, config, context, reportPath) => {
 
 const log$1 = logger.channel('builder:bundle:rollup:dispatch');
 const REPORT_DIR_PREFIX = 'hf-builder-rollup-';
-const SWC_NODE_REGISTER = '@swc-node/register';
-const swcNodeAvailable = (workspaceRoot) => existsSync(join$2(workspaceRoot, 'node_modules', '@swc-node', 'register', 'index.js'));
 /**
- * Default worker-path resolution: prefers the built-and-published artifact, falls
- * back to the workspace dist path, and finally to the in-source TypeScript file
- * via `@swc-node/register` (bootstrap case where builder is building itself for
- * the first time and the dist worker doesn't exist yet).
- *
- * Looks at, in order:
- * 1. `<workspaceRoot>/dist/libs/builder/bundle/rollup/worker/index.cjs.js`
- * 2. `<workspaceRoot>/node_modules/@hyperfrontend/builder/bundle/rollup/worker/index.cjs.js`
- * 3. `<workspaceRoot>/libs/builder/src/bundle/rollup/worker/index.ts` (with `--require \@swc-node/register`)
- *
- * @param workspaceRoot - Absolute workspace root.
- * @returns Worker invocation descriptor, or `undefined` if no candidate exists.
- *
- * @example Locating the worker for an in-workspace consumer
+ * 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('/abs/repo')
+ * const invocation = resolveDefaultRollupWorkerPath()
  * 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 resolveDefaultRollupWorkerPath = (startDir) => ascendForWorker(['bundle', 'rollup', 'worker'], startDir);
 const createReportDir = () => mkdtempSync(join$2(tmpdir(), REPORT_DIR_PREFIX));
 const reportPathFor = (reportDir, descriptor) => {
     const safeLabel = descriptor.inputFile.replace(/[^a-zA-Z0-9_-]+/g, '_');
@@ -3527,25 +3555,25 @@ const buildWorkspaceJsPrePassJobs = (npmDeps, formats, context) => {
     }
     return jobs;
 };
-const resolvePrePassWorkerOrThrow = (workspaceRoot) => {
-    const invocation = resolveDefaultWorkerPath(workspaceRoot);
+const resolvePrePassWorkerOrThrow = () => {
+    const invocation = resolveDefaultWorkerPath();
     if (!invocation) {
-        throw createError('bundleAllDeps is enabled but the pre-pass worker could not be resolved. Build @hyperfrontend/builder once with bundleAllDeps disabled, or ensure @swc-node/register is installed for source-mode bootstrap.');
+        throw createError('bundleAllDeps is enabled but the pre-pass worker could not be located beside the builder module. The @hyperfrontend/builder package appears incomplete, or @swc-node/register is missing for source-mode bootstrap.');
     }
     return invocation;
 };
-const resolveRollupWorkerOrThrow = (workspaceRoot) => {
-    const invocation = resolveDefaultRollupWorkerPath(workspaceRoot);
+const resolveRollupWorkerOrThrow = () => {
+    const invocation = resolveDefaultRollupWorkerPath();
     if (!invocation) {
-        throw createError('rollup worker could not be resolved. Build @hyperfrontend/builder at least once before invoking the bundle phase, or ensure @swc-node/register is installed for source-mode bootstrap.');
+        throw createError('rollup worker could not be located beside the builder module. The @hyperfrontend/builder package appears incomplete, or @swc-node/register is missing for source-mode bootstrap.');
     }
     return invocation;
 };
-const createLazyDispatchResolver = (workspaceRoot) => {
+const createLazyDispatchResolver = () => {
     let cached = null;
     return () => {
         if (!cached) {
-            const invocation = resolveRollupWorkerOrThrow(workspaceRoot);
+            const invocation = resolveRollupWorkerOrThrow();
             cached = { workerPath: invocation.path, execArgv: invocation.execArgv };
         }
         return cached;
@@ -3639,7 +3667,7 @@ const runBundlePhase = async (context, config, monitor) => {
     const outputs = { esm: [], cjs: [], iife: [], umd: [] };
     const requestedPrePassFormats = collectFormatsRequestingPrePass(config);
     if (requestedPrePassFormats.length > 0 && (context.bundledDeps.length > 0 || context.workspaceBundledDeps.length > 0)) {
-        const invocation = resolvePrePassWorkerOrThrow(context.workspaceRoot);
+        const invocation = resolvePrePassWorkerOrThrow();
         const npmJobs = buildJsPrePassJobs(context.bundledDeps, requestedPrePassFormats, context);
         const workspaceJobs = buildWorkspaceJsPrePassJobs(context.bundledDeps, requestedPrePassFormats, context);
         const jobs = [...npmJobs, ...workspaceJobs];
@@ -3648,7 +3676,7 @@ const runBundlePhase = async (context, config, monitor) => {
         await runPrePass(jobs, { workerPath: invocation.path, execArgv: invocation.execArgv, monitor });
         monitor?.check('bundle:dependencies:prepass:end');
     }
-    const resolveDispatch = createLazyDispatchResolver(context.workspaceRoot);
+    const resolveDispatch = createLazyDispatchResolver();
     await runEsmFormats(config, context, outputs, resolveDispatch, monitor);
     await recover();
     monitor?.check('bundle:esm:end:post-recover');

package/bundle/rollup/dispatch.d.ts

@@ -26,26 +26,24 @@ export interface RollupWorkerInvocation {
     execArgv: string[];
 }
 /**
- * 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).
+ * 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.
  *
- * 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 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.
  *
- * @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 Locating the worker beside the builder
  * ```typescript
- * const invocation = resolveDefaultRollupWorkerPath('/abs/repo')
+ * const invocation = resolveDefaultRollupWorkerPath()
  * if (!invocation) throw new Error('builder rollup worker artifact not found')
  * ```
  */
-export declare const resolveDefaultRollupWorkerPath: (workspaceRoot: string) => RollupWorkerInvocation | undefined;
+export declare const resolveDefaultRollupWorkerPath: (startDir?: string) => RollupWorkerInvocation | undefined;
 /**
  * Forks a single rollup worker for the supplied descriptor and waits for it
  * to exit. The caller-provided descriptor's `reportPath` is overwritten with

package/bundle/rollup/dispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/rollup/dispatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAY/E;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,iGAAiG;IACjG,UAAU,EAAE,MAAM,CAAA;IAClB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,aAAa,CAAA;IACvB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,uGAAuG;IACvG,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,yFAAyF;IACzF,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAA;IACZ,wDAAwD;IACxD,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB;AAQD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,8BAA8B,GAAI,eAAe,MAAM,KAAG,sBAAsB,GAAG,SAa/F,CAAA;AA4CD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,YAAY,qBAAqB,EACjC,SAAS,2BAA2B,KACnC,OAAO,CAAC,kBAAkB,CAkB5B,CAAA"}
+{"version":3,"file":"dispatch.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/rollup/dispatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAA;AAa/E;;GAEG;AACH,MAAM,WAAW,2BAA2B;IAC1C,iGAAiG;IACjG,UAAU,EAAE,MAAM,CAAA;IAClB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,aAAa,CAAA;IACvB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,uGAAuG;IACvG,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,yFAAyF;IACzF,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAA;IACZ,wDAAwD;IACxD,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB;AAID;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,8BAA8B,GAAI,WAAW,MAAM,KAAG,sBAAsB,GAAG,SACjC,CAAA;AA4C3D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,oBAAoB,GAC/B,YAAY,qBAAqB,EACjC,SAAS,2BAA2B,KACnC,OAAO,CAAC,kBAAkB,CAkB5B,CAAA"}

package/bundle/rollup/index.cjs.js

@@ -321,45 +321,91 @@ const toUmdBuildDescriptor = (entry, config, context, reportPath) => {
     };
 };
 
-const log = index_cjs_js$7.logger.channel('builder:bundle:rollup:dispatch');
-const REPORT_DIR_PREFIX = 'hf-builder-rollup-';
 const SWC_NODE_REGISTER = '@swc-node/register';
-const swcNodeAvailable = (workspaceRoot) => node_fs.existsSync(index_cjs_js$5.join(workspaceRoot, 'node_modules', '@swc-node', 'register', 'index.js'));
+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;
+};
 /**
- * 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 = [
-        index_cjs_js$5.join(workspaceRoot, 'dist', 'libs', 'builder', 'bundle', 'rollup', 'worker', 'index.cjs.js'),
-        index_cjs_js$5.join(workspaceRoot, 'node_modules', '@hyperfrontend', 'builder', 'bundle', 'rollup', 'worker', 'index.cjs.js'),
-    ];
-    for (const path of distCandidates) {
-        if (node_fs.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 index_cjs_js$4.createError('@hyperfrontend/builder self-location requires the CommonJS build; drive build() from the CommonJS entry point');
     }
-    const sourcePath = index_cjs_js$5.join(workspaceRoot, 'libs', 'builder', 'src', 'bundle', 'rollup', 'worker', 'index.ts');
-    if (node_fs.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 = 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 undefined;
+    return probeDir(dir, offset);
 };
+
+const log = index_cjs_js$7.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 = () => node_fs.mkdtempSync(index_cjs_js$5.join(node_os.tmpdir(), REPORT_DIR_PREFIX));
 const reportPathFor = (reportDir, descriptor) => {
     const safeLabel = descriptor.inputFile.replace(/[^a-zA-Z0-9_-]+/g, '_');

package/bundle/rollup/index.d.ts

@@ -29,26 +29,24 @@ interface RollupWorkerInvocation {
     execArgv: string[];
 }
 /**
- * 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
+ * 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('/abs/repo')
+ * const invocation = resolveDefaultRollupWorkerPath()
  * if (!invocation) throw new Error('builder rollup worker artifact not found')
  * ```
  */
-declare const resolveDefaultRollupWorkerPath: (workspaceRoot: string) => RollupWorkerInvocation | undefined;
+declare const resolveDefaultRollupWorkerPath: (startDir?: string) => RollupWorkerInvocation | undefined;
 /**
  * Forks a single rollup worker for the supplied descriptor and waits for it
  * to exit. The caller-provided descriptor's `reportPath` is overwritten with

package/bundle/rollup/index.esm.js

@@ -8,7 +8,7 @@ import { exists, readJsonFile } from '../../_dependencies/@hyperfrontend/project
 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 { existsSync, rmSync, 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';
@@ -311,45 +311,91 @@ const toUmdBuildDescriptor = (entry, config, context, 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'));
+const probeDir = (dir, offset) => {
+    const compiled = join$1(dir, ...offset, 'index.cjs.js');
+    if (existsSync(compiled))
+        return { path: compiled, execArgv: [] };
+    const source = join$1(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$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 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$2(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 = 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$2(tmpdir(), REPORT_DIR_PREFIX));
 const reportPathFor = (reportDir, descriptor) => {
     const safeLabel = descriptor.inputFile.replace(/[^a-zA-Z0-9_-]+/g, '_');