@hyperfrontend/builder 0.1.0

package/bundle/dependencies/index.cjs.js

@@ -0,0 +1,964 @@
+'use strict';
+
+const node_module = require('node:module');
+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$4 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.cjs.js');
+const index_cjs_js$3 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/json/index.cjs.js');
+const index_cjs_js$2 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/promise/index.cjs.js');
+const index_cjs_js = require('../../_dependencies/@hyperfrontend/logging/index.cjs.js');
+const index_cjs_js$1 = require('../../_dependencies/@hyperfrontend/project-scope/core/index.cjs.js');
+const index_cjs_js$7 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.cjs.js');
+const index_cjs_js$6 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.cjs.js');
+const index_cjs_js$5 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/set/index.cjs.js');
+const index_cjs_js$8 = require('../../_dependencies/@hyperfrontend/project-scope/core/fs/index.cjs.js');
+const index_cjs_js$a = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/map/index.cjs.js');
+const index_cjs_js$9 = require('../../_dependencies/@hyperfrontend/project-scope/core/path/index.cjs.js');
+const commonjs = require('../../_dependencies/@rollup/plugin-commonjs/index.cjs.js');
+const json = require('../../_dependencies/@rollup/plugin-json/index.cjs.js');
+const nodeResolve = require('../../_dependencies/@rollup/plugin-node-resolve/index.cjs.js');
+const typescript = require('../../_dependencies/@rollup/plugin-typescript/index.cjs.js');
+const index_cjs_js$b = require('../../_dependencies/rollup/index.cjs.js');
+const { normalizeToForwardSlashes, join } = require('../../_shared/bundle/fs/posix-path/index.cjs.js');
+const { relativeImport, buildWorkspaceRoutes, createExternalizeBundledDepsPlugin } = require('../../_shared/bundle/dependencies/externalize-plugin/index.cjs.js');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e : { default: e }; }
+
+const commonjs__default = /*#__PURE__*/_interopDefaultCompat(commonjs);
+const json__default = /*#__PURE__*/_interopDefaultCompat(json);
+const nodeResolve__default = /*#__PURE__*/_interopDefaultCompat(nodeResolve);
+const typescript__default = /*#__PURE__*/_interopDefaultCompat(typescript);
+
+const log = index_cjs_js.logger.channel('builder:bundle:dependencies:pre-pass');
+const REPORT_DIR_PREFIX = 'hf-builder-prepass-';
+const createReportDir = () => node_fs.mkdtempSync(index_cjs_js$1.join(node_os.tmpdir(), REPORT_DIR_PREFIX));
+const reportPathFor = (reportDir, job, index) => index_cjs_js$1.join(reportDir, `${index}-${job.dep.replace(/\//g, '__')}-${job.kind}-${job.format}.json`);
+const runOne = (job, reportPath, options) => index_cjs_js$2.createPromise((resolve, reject) => {
+    const execPath = options.execPath ?? process.execPath;
+    const argv = [...(options.execArgv ?? []), options.workerPath, index_cjs_js$3.stringify({ ...job, reportPath })];
+    const child = node_child_process.spawn(execPath, argv, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let capturedStderr = '';
+    child.stdout?.on('data', (chunk) => {
+        process.stdout.write(chunk);
+    });
+    child.stderr?.on('data', (chunk) => {
+        const text = typeof chunk === 'string' ? chunk : chunk.toString();
+        capturedStderr += text;
+        process.stderr.write(text);
+    });
+    child.on('error', (error) => {
+        reject(index_cjs_js$4.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$4.createError(`pre-pass worker for ${job.dep} (${job.kind}/${job.format}) exited with code ${code}\n${tail}`));
+            return;
+        }
+        resolve();
+    });
+});
+const readReport = (reportPath, job) => {
+    if (!node_fs.existsSync(reportPath)) {
+        throw index_cjs_js$4.createError(`pre-pass worker for ${job.dep} (${job.kind}/${job.format}) did not write a report at ${reportPath}`);
+    }
+    const data = index_cjs_js$3.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$1.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
+ * ```typescript
+ * const invocation = resolveDefaultWorkerPath('/abs/repo')
+ * if (!invocation) throw new Error('builder worker artifact not found')
+ * ```
+ */
+const resolveDefaultWorkerPath = (workspaceRoot) => {
+    const distCandidates = [
+        index_cjs_js$1.join(workspaceRoot, 'dist', 'libs', 'builder', 'bundle', 'dependencies', 'worker', 'index.cjs.js'),
+        index_cjs_js$1.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$1.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;
+};
+/**
+ * Sequentially runs the supplied pre-pass jobs by forking a fresh Node child
+ * per invocation. Strict sequential execution is mandatory — concurrent
+ * children would simultaneously pressure RAM and OOM the container.
+ *
+ * Each child writes a JSON report to a parent-supplied path; this function
+ * reads the report after the child exits and accumulates per-job statistics.
+ * If any worker exits non-zero or fails to produce a report, the function
+ * throws with the failed job's context.
+ *
+ * The report directory is created in the OS temp dir and removed before
+ * returning, regardless of success or failure.
+ *
+ * @param jobs - Pre-pass jobs to run.
+ * @param options - Worker path + optional memory monitor.
+ * @returns One result per supplied job, in the order the jobs were given.
+ *
+ * @example Pre-passing rollup and one of its plugins
+ * ```typescript
+ * const results = await runPrePass(jobs, { workerPath: '/abs/dist/libs/builder/bundle/dependencies/worker.cjs.js' })
+ * ```
+ */
+const runPrePass = async (jobs, options) => {
+    if (jobs.length === 0)
+        return [];
+    const reportDir = createReportDir();
+    const results = [];
+    try {
+        for (const [index, job] of jobs.entries()) {
+            const reportPath = reportPathFor(reportDir, job, index);
+            log.info(`pre-pass ${index + 1}/${jobs.length}: ${job.dep} (${job.kind}/${job.format})`);
+            options.monitor?.check(`bundle:dependencies:prepass:${index + 1}/${jobs.length}:${job.dep}:${job.kind}:${job.format}:start`);
+            await runOne(job, reportPath, options);
+            const result = readReport(reportPath, job);
+            log.debug(`pre-pass ${index + 1}/${jobs.length} done: ${job.dep} size=${result.outputSize}B heap=${result.endHeapMB.toFixed(1)}MB rss=${result.endRssMB.toFixed(1)}MB t=${result.durationMs}ms`);
+            options.monitor?.check(`bundle:dependencies:prepass:${index + 1}/${jobs.length}:${job.dep}:${job.kind}:${job.format}:end`);
+            results.push(result);
+        }
+        return results;
+    }
+    finally {
+        node_fs.rmSync(reportDir, { recursive: true, force: true });
+    }
+};
+
+/**
+ * Packages that are never eligible for bundling, regardless of how they're
+ * declared or what overrides the caller supplies.
+ *
+ * `typescript` is the lone permanent entry: it is a consumer requirement of
+ * every `@hyperfrontend/builder` project, far too large to inline, and its
+ * monolithic `lib/typescript.d.ts` defeats `rollup-plugin-dts`. The framework
+ * refuses to bundle it so this invariant cannot be undone by configuration.
+ */
+const ALWAYS_EXCLUDED = index_cjs_js$5.createSet(['typescript']);
+const readPkg$1 = (packageJsonPath) => (index_cjs_js$8.exists(packageJsonPath) ? index_cjs_js$8.readJsonFile(packageJsonPath) : {});
+/**
+ * Resolves the list of third-party dependencies that should be pre-passed
+ * (bundled once into `_dependencies/<dep>/`) for the build.
+ *
+ * Algorithm:
+ * 1. Read `dependencies` from the project's `package.json`.
+ * 2. Subtract `peerDependencies` — those stay external.
+ * 3. Subtract anything matching `isWorkspacePackage` — workspace deps are inlined per the existing flow.
+ * 4. Apply `include` / `exclude` overrides.
+ *
+ * The returned list is sorted and de-duplicated.
+ *
+ * @param packageJsonPath - Absolute path to the project's `package.json`.
+ * @param options - Caller overrides.
+ * @returns Sorted list of third-party package names to pre-pass.
+ *
+ * @example Resolving bundled deps for a workspace library
+ * ```typescript
+ * const deps = resolveBundledDeps('/abs/libs/foo/package.json', {
+ *   isWorkspacePackage: (n) => n.startsWith('@hyperfrontend/'),
+ * })
+ * ```
+ */
+const resolveBundledDeps = (packageJsonPath, options = {}) => {
+    const pkg = readPkg$1(packageJsonPath);
+    const deps = index_cjs_js$6.keys(pkg.dependencies ?? {});
+    const peerDeps = index_cjs_js$5.createSet(index_cjs_js$6.keys(pkg.peerDependencies ?? {}));
+    const isWorkspace = options.isWorkspacePackage ?? (() => false);
+    const includeSet = index_cjs_js$5.createSet(options.include ?? []);
+    const excludeSet = index_cjs_js$5.createSet(options.exclude ?? []);
+    const eligible = deps.filter((name) => !peerDeps.has(name) && !isWorkspace(name) && !ALWAYS_EXCLUDED.has(name));
+    const merged = index_cjs_js$5.createSet([...eligible, ...includeSet]);
+    const filtered = index_cjs_js$7.from(merged).filter((name) => !excludeSet.has(name) && !peerDeps.has(name) && !isWorkspace(name) && !ALWAYS_EXCLUDED.has(name));
+    return filtered.sort();
+};
+
+const readPkg = (packageJsonPath) => (index_cjs_js$8.exists(packageJsonPath) ? index_cjs_js$8.readJsonFile(packageJsonPath) : {});
+const dirnameOf$1 = (filePath) => {
+    const normalized = index_cjs_js$9.normalizeToForwardSlashes(filePath);
+    const idx = normalized.lastIndexOf('/');
+    return idx <= 0 ? normalized : normalized.slice(0, idx);
+};
+const absolutize = (relativeTo, value) => {
+    if (node_path.isAbsolute(value))
+        return index_cjs_js$9.normalizeToForwardSlashes(value);
+    return index_cjs_js$9.normalizeToForwardSlashes(node_path.resolve(relativeTo, value));
+};
+/**
+ * Reads a tsconfig and follows its `extends` chain to merge `compilerOptions.paths`.
+ * Later (i.e. inheriting) configs win on key collisions. Each `paths` entry is
+ * stored relative to the originating tsconfig's `baseUrl`, which is itself
+ * relative to the tsconfig's directory; we absolutize as we go so callers can
+ * rely on the returned values being absolute.
+ *
+ * The function tolerates missing `extends` targets — a typical layout has the
+ * project tsconfig extending a workspace-root one, which extends nothing.
+ *
+ * @param tsconfigPath - Absolute path to the tsconfig to read.
+ * @param visited - Set of tsconfig paths already followed (cycle guard).
+ * @returns Map keyed by `paths` entry name, with each value an array of absolute candidate paths.
+ */
+const readTsconfigPaths = (tsconfigPath, visited = index_cjs_js$5.createSet([])) => {
+    const result = index_cjs_js$a.createMap([]);
+    if (visited.has(tsconfigPath))
+        return result;
+    visited.add(tsconfigPath);
+    const fragment = index_cjs_js$8.readJsonFileIfExists(tsconfigPath);
+    if (!fragment)
+        return result;
+    if (fragment.extends) {
+        const extendsPath = absolutize(dirnameOf$1(tsconfigPath), fragment.extends);
+        const extendsResolved = extendsPath.endsWith('.json') ? extendsPath : `${extendsPath}.json`;
+        const inherited = readTsconfigPaths(extendsResolved, visited);
+        for (const [key, paths] of inherited)
+            result.set(key, paths);
+    }
+    const localBaseUrl = absolutize(dirnameOf$1(tsconfigPath), fragment.compilerOptions?.baseUrl ?? '.');
+    const localPaths = fragment.compilerOptions?.paths ?? {};
+    for (const key of index_cjs_js$6.keys(localPaths)) {
+        const list = (localPaths[key] ?? []).map((rel) => absolutize(localBaseUrl, rel));
+        result.set(key, list);
+    }
+    return result;
+};
+/**
+ * Loads tsconfig path-mappings from a workspace, preferring `tsconfig.base.json`
+ * at the workspace root and falling back to a `tsconfig.json` extends chain when
+ * the base form is absent.
+ *
+ * @param workspaceRoot - Absolute workspace root.
+ * @returns Map keyed by tsconfig `paths` key (e.g. `@hyperfrontend/logging`),
+ * with values pointing at absolute source files.
+ *
+ * @example Loading the workspace's path-mapping table
+ * ```typescript
+ * const paths = loadWorkspacePathMappings('/abs/repo')
+ * paths.get('@hyperfrontend/logging') // => ['/abs/repo/libs/logging/src/index.ts']
+ * ```
+ */
+const loadWorkspacePathMappings = (workspaceRoot) => {
+    const candidates = [index_cjs_js$9.join(workspaceRoot, 'tsconfig.base.json'), index_cjs_js$9.join(workspaceRoot, 'tsconfig.json')];
+    for (const candidate of candidates) {
+        if (!index_cjs_js$8.exists(candidate))
+            continue;
+        const map = readTsconfigPaths(candidate);
+        if (map.size > 0)
+            return map;
+    }
+    return index_cjs_js$a.createMap([]);
+};
+/**
+ * Splits a tsconfig key like `@hyperfrontend/foo/bar/baz` into the package name
+ * (`@hyperfrontend/foo`) and the sub-path (`bar/baz`). Returns `''` for the
+ * sub-path when the key is the package root.
+ *
+ * @param specifier - Tsconfig `paths` key.
+ * @returns Split into `packageName` and `subPath`.
+ */
+const splitSpecifier = (specifier) => {
+    if (specifier.startsWith('@')) {
+        const slashAfterScope = specifier.indexOf('/');
+        if (slashAfterScope < 0)
+            return { packageName: specifier, subPath: '' };
+        const slashAfterName = specifier.indexOf('/', slashAfterScope + 1);
+        if (slashAfterName < 0)
+            return { packageName: specifier, subPath: '' };
+        return { packageName: specifier.slice(0, slashAfterName), subPath: specifier.slice(slashAfterName + 1) };
+    }
+    const slash = specifier.indexOf('/');
+    if (slash < 0)
+        return { packageName: specifier, subPath: '' };
+    return { packageName: specifier.slice(0, slash), subPath: specifier.slice(slash + 1) };
+};
+const firstResolvable = (paths) => {
+    for (const candidate of paths) {
+        if (index_cjs_js$8.exists(candidate))
+            return candidate;
+    }
+    return undefined;
+};
+/**
+ * Walks parent directories upward from `fromPath` until a `package.json` is
+ * found, then returns the directory that owns it. Used to pin a workspace
+ * dep's source file back to its own project root so we can locate that dep's
+ * tsconfig.
+ *
+ * @param fromPath - Absolute path to a `.ts` source file inside the dep.
+ * @returns The dep's project-root directory, or `undefined` when no `package.json` ancestor exists.
+ */
+const findOwningProjectRoot = (fromPath) => {
+    const normalized = index_cjs_js$9.normalizeToForwardSlashes(fromPath);
+    const segments = normalized.split('/').filter((s) => s.length > 0);
+    for (let i = segments.length; i > 0; i--) {
+        const candidateDir = `/${segments.slice(0, i).join('/')}`;
+        if (index_cjs_js$8.exists(`${candidateDir}/package.json`))
+            return candidateDir;
+    }
+    return undefined;
+};
+const TSCONFIG_CANDIDATES = ['tsconfig.lib.json', 'tsconfig.json'];
+/**
+ * Locates the tsconfig the typescript plugin should use when transforming a
+ * workspace dep's source. Prefers `tsconfig.lib.json` (the build-time config
+ * used by the dep itself) and falls back to `tsconfig.json` so non-publishable
+ * deps remain compilable.
+ *
+ * @param projectRoot - Absolute path to the dep's project-root directory.
+ * @returns Absolute path to the chosen tsconfig, or `undefined` when none of the candidates exist.
+ */
+const findDepTsConfig = (projectRoot) => {
+    for (const name of TSCONFIG_CANDIDATES) {
+        const candidate = index_cjs_js$9.join(projectRoot, name);
+        if (index_cjs_js$8.exists(candidate))
+            return candidate;
+    }
+    return undefined;
+};
+const collectMatchingSpecifiers = (packageName, mappings) => {
+    const matches = [];
+    for (const [specifier, paths] of mappings) {
+        const split = splitSpecifier(specifier);
+        if (split.packageName !== packageName)
+            continue;
+        const inputPath = firstResolvable(paths);
+        if (!inputPath)
+            continue;
+        matches.push({ specifier, inputPath });
+    }
+    return matches;
+};
+/**
+ * Resolves the list of workspace `@hyperfrontend/*` deps that should be hoisted
+ * into `_dependencies/<name>(/<sub>)?/index.<ext>.js`.
+ *
+ * Algorithm:
+ * 1. Read the project's `package.json#dependencies`, retain entries matching
+ *    `isWorkspacePackage`, and apply caller `include` / `exclude` overrides.
+ *    Peer deps and excluded packages are skipped; `include` cannot resurrect a
+ *    peer dep.
+ * 2. Load workspace path-mappings (tsconfig `paths`).
+ * 3. For each eligible workspace dep, apply the per-dep hoist policy
+ *    (`options.policy`, defaulting to `'sub-path'`):
+ *    - `'sub-path'` (the zero-config default) emits one entry per resolvable
+ *      tsconfig specifier (root + every sub-path with a real source file),
+ *      preserving sub-module granularity and supporting subpath-only packages
+ *      that expose no root export.
+ *    - `'whole-surface'` is an explicit opt-in collapse: it emits a single entry
+ *      for the package root, so it requires the dep to expose a root export.
+ * 4. The returned list is sorted by `specifier` for stable downstream ordering.
+ *
+ * Because the caller requested `bundleAllDeps`, an eligible dep that cannot be
+ * fully resolved is a contract violation, not a soft skip. The function throws
+ * (rather than silently externalising) when an eligible dep has no resolvable
+ * tsconfig mapping, when a mapped source has no owning tsconfig, or when a dep
+ * is explicitly opted into `'whole-surface'` yet exposes no root export — each
+ * with a message naming the dep and the remedy.
+ *
+ * @param packageJsonPath - Absolute path to the project's `package.json`.
+ * @param workspaceRoot - Absolute workspace root used to load `tsconfig.base.json` paths.
+ * @param options - Caller overrides + workspace-package predicate + per-package policy map.
+ * @returns Resolved workspace-dep pre-pass entries sorted by specifier.
+ * @throws {Error} When an eligible workspace dep cannot be bundled (no mapping, no root export under `'whole-surface'`, or no owning tsconfig).
+ *
+ * @example Resolving workspace pre-pass entries for builder
+ * ```typescript
+ * const entries = resolveWorkspaceBundledDeps(
+ *   '/abs/libs/builder/package.json',
+ *   '/abs/repo',
+ *   { isWorkspacePackage: (n) => n.startsWith('@hyperfrontend/') }
+ * )
+ * ```
+ */
+const resolveWorkspaceBundledDeps = (packageJsonPath, workspaceRoot, options) => {
+    const pkg = readPkg(packageJsonPath);
+    const declared = index_cjs_js$6.keys(pkg.dependencies ?? {});
+    const peerDeps = index_cjs_js$5.createSet(index_cjs_js$6.keys(pkg.peerDependencies ?? {}));
+    const includeSet = index_cjs_js$5.createSet(options.include ?? []);
+    const excludeSet = index_cjs_js$5.createSet(options.exclude ?? []);
+    const isWorkspace = options.isWorkspacePackage;
+    const policyMap = options.policy ?? {};
+    // why: granularity is the zero-config default — every public sub-path becomes its own chunk so consumers reuse/tree-shake at sub-module resolution, and subpath-only packages resolve with no configuration. `'whole-surface'` is an explicit opt-in collapse.
+    const policyFor = (name) => policyMap[name] ?? 'sub-path';
+    const eligible = declared.filter((name) => isWorkspace(name) && !peerDeps.has(name));
+    const merged = index_cjs_js$5.createSet([...eligible, ...index_cjs_js$7.from(includeSet).filter((name) => isWorkspace(name) && !peerDeps.has(name))]);
+    const filtered = index_cjs_js$7.from(merged).filter((name) => !excludeSet.has(name));
+    if (filtered.length === 0)
+        return [];
+    const mappings = loadWorkspacePathMappings(workspaceRoot);
+    const results = [];
+    const tsConfigByPackage = index_cjs_js$a.createMap([]);
+    const resolveTsConfigForPackage = (inputPath) => {
+        const projectRoot = findOwningProjectRoot(inputPath);
+        if (!projectRoot)
+            return undefined;
+        const cached = tsConfigByPackage.get(projectRoot);
+        if (cached)
+            return cached;
+        const found = findDepTsConfig(projectRoot);
+        if (found)
+            tsConfigByPackage.set(projectRoot, found);
+        return found;
+    };
+    for (const packageName of filtered) {
+        const matches = collectMatchingSpecifiers(packageName, mappings);
+        if (matches.length === 0) {
+            throw index_cjs_js$4.createError(`bundleAllDeps: workspace dependency "${packageName}" has no resolvable tsconfig path mapping under ${workspaceRoot} (no matching paths entry, or its mapped source files are missing), so it cannot be bundled. Add a "${packageName}" (or "${packageName}/<sub-path>") entry to tsconfig.base.json paths pointing at an existing source file, or exclude it via bundleAllDeps.exclude.`);
+        }
+        const policy = policyFor(packageName);
+        const pushEntry = (specifier, inputPath) => {
+            const tsConfigPath = resolveTsConfigForPackage(inputPath);
+            if (!tsConfigPath) {
+                throw index_cjs_js$4.createError(`bundleAllDeps: workspace dependency "${specifier}" resolves to ${inputPath}, but no tsconfig (tsconfig.lib.json / tsconfig.json) was found in its project root, so it cannot be transformed during bundling.`);
+            }
+            const split = splitSpecifier(specifier);
+            results.push({ packageName, subPath: split.subPath, specifier, inputPath, tsConfigPath, policy });
+        };
+        if (policy === 'whole-surface') {
+            const root = matches.find((m) => m.specifier === packageName);
+            if (!root) {
+                throw index_cjs_js$4.createError(`bundleAllDeps: workspace dependency "${packageName}" is explicitly set to the 'whole-surface' hoist policy but is subpath-only (no root export; tsconfig exposes only ${matches.map((m) => `"${m.specifier}"`).join(', ')}). Remove the 'whole-surface' override for it (sub-path is the default), or add a root export.`);
+            }
+            pushEntry(root.specifier, root.inputPath);
+            continue;
+        }
+        for (const match of matches)
+            pushEntry(match.specifier, match.inputPath);
+    }
+    return results.sort((a, b) => a.specifier.localeCompare(b.specifier));
+};
+
+const stripTrailingIndexDts = (filePath) => {
+    const normalized = normalizeToForwardSlashes(filePath);
+    const trimmed = normalized.replace(/\/index\.d\.ts$/, '');
+    return trimmed === normalized ? normalized.replace(/\.d\.ts$/, '') : trimmed;
+};
+const stripTrailingSlash = (value) => (value.endsWith('/') ? value.slice(0, -1) : value);
+const dirnameOf = (filePath) => {
+    const normalized = normalizeToForwardSlashes(filePath);
+    const idx = normalized.lastIndexOf('/');
+    return idx <= 0 ? normalized : normalized.slice(0, idx);
+};
+/**
+ * Computes the directory (without trailing slash) that owns a sibling's
+ * `index.d.ts`. Used to test whether an absolute resolved id falls inside the
+ * sibling's directory tree.
+ *
+ * @param sibling - Sibling-entry record.
+ * @returns Sibling's directory with no trailing slash.
+ */
+const siblingDir = (sibling) => stripTrailingSlash(dirnameOf(sibling.indexDtsPath));
+const startsWithDir = (resolved, dir) => {
+    const normalizedResolved = normalizeToForwardSlashes(resolved);
+    if (normalizedResolved === dir)
+        return true;
+    return normalizedResolved.startsWith(`${dir}/`);
+};
+/**
+ * Returns the sibling entry whose directory contains `absolutePath`, or `undefined`
+ * when no sibling owns the path.
+ *
+ * @param absolutePath - Resolved absolute path of an import.
+ * @param siblings - Sibling-entry records.
+ * @returns Owning sibling entry, or `undefined`.
+ *
+ * @example Identifying a sibling for a resolved type import
+ * ```typescript
+ * const owner = findOwningSibling('/abs/dist/libs/foo/models/index.d.ts', siblings)
+ * ```
+ */
+const findOwningSibling = (absolutePath, siblings) => {
+    const normalized = normalizeToForwardSlashes(absolutePath);
+    let best;
+    let bestDirLength = -1;
+    for (const sibling of siblings) {
+        const dir = siblingDir(sibling);
+        if (!startsWithDir(normalized, dir))
+            continue;
+        if (dir.length > bestDirLength) {
+            best = sibling;
+            bestDirLength = dir.length;
+        }
+    }
+    return best;
+};
+/**
+ * Computes the bare-specifier form of a sibling import as emitted in the
+ * rewritten `.d.ts` (e.g., `../models`, `../../models`, `./bundle/declarations`).
+ *
+ * Always omits the trailing `index.d.ts` so both `moduleResolution: 'bundler'`
+ * and `node` accept it.
+ *
+ * @param selfDtsPath - Absolute path to the current entry's `index.d.ts`.
+ * @param sibling - The sibling entry being targeted.
+ * @returns POSIX-style relative specifier ready for `id` in a rollup external resolution.
+ *
+ * @example Computing a sibling import from `bundle/index.d.ts` to `models/`
+ * ```typescript
+ * computeSiblingSpecifier(
+ *   '/abs/dist/libs/foo/bundle/index.d.ts',
+ *   { srcPath: 'models', indexDtsPath: '/abs/dist/libs/foo/models/index.d.ts' }
+ * ) // => '../models'
+ * ```
+ */
+const computeSiblingSpecifier = (selfDtsPath, sibling) => {
+    const fromDir = dirnameOf(selfDtsPath);
+    const toDir = siblingDir(sibling);
+    const fromSegments = fromDir.split('/').filter((s) => s.length > 0);
+    const toSegments = toDir.split('/').filter((s) => s.length > 0);
+    let common = 0;
+    while (common < fromSegments.length && common < toSegments.length && fromSegments[common] === toSegments[common]) {
+        common += 1;
+    }
+    const upSegments = fromSegments.length - common;
+    const downSegments = toSegments.slice(common);
+    if (upSegments === 0 && downSegments.length === 0)
+        return '.';
+    const ups = '../'.repeat(upSegments);
+    const downs = downSegments.join('/');
+    if (upSegments === 0)
+        return `./${downs}`;
+    return downs.length > 0 ? `${ups}${downs}` : ups.replace(/\/$/, '');
+};
+/**
+ * Resolves a relative or absolute `source` against `importer` (or `selfDtsPath`
+ * when no importer is given) and returns the absolute filesystem candidate
+ * suitable for matching against sibling entries.
+ *
+ * Mirrors TypeScript's lookup rules at the level we need: when the candidate
+ * exists as `<candidate>/index.d.ts` we treat that as the resolved file,
+ * otherwise the candidate path itself.
+ *
+ * @param source - The import specifier as it appears in source.
+ * @param importer - Absolute path of the importing module, when known.
+ * @param selfDtsPath - Absolute path to the entry currently being rewritten (fallback importer).
+ * @returns Absolute candidate path for sibling matching.
+ */
+const resolveCandidate = (source, importer, selfDtsPath) => {
+    if (node_path.isAbsolute(source))
+        return normalizeToForwardSlashes(source);
+    if (source.startsWith('.')) {
+        const fromDir = dirnameOf(importer ?? selfDtsPath);
+        return normalizeToForwardSlashes(node_path.resolve(fromDir, source));
+    }
+    return source;
+};
+/**
+ * Returns a rollup plugin that externalizes any import resolving inside a
+ * sibling entry's directory tree, rewriting the emitted specifier to a POSIX
+ * relative path stripped of `/index` and `.d.ts` suffixes.
+ *
+ * The plugin's `resolveId` hook returns `null` for everything that does not
+ * resolve into a sibling — that lets the rest of the rollup-plugin-dts chain
+ * inline third-party type imports as before.
+ *
+ * Self-ownership is enforced by adding the current entry into the ownership
+ * pool: when the deepest-matching entry directory is the entry being rewritten
+ * (and not a sibling), the resolver returns `null` so rollup keeps the path
+ * internal. This matters for the package root entry whose directory prefix-
+ * matches every other entry's path — without including self, root would
+ * spuriously claim its own subtree's files.
+ *
+ * @param input - Self + sibling entry descriptors.
+ * @returns Rollup plugin.
+ *
+ * @example Plugin instance for the bundle entry pass
+ * ```typescript
+ * const plugin = createSiblingExternalizePlugin({
+ *   selfSrcPath: 'bundle',
+ *   selfDtsPath: '/abs/dist/libs/foo/bundle/index.d.ts',
+ *   siblings: [{ srcPath: 'models', indexDtsPath: '/abs/dist/libs/foo/models/index.d.ts' }],
+ * })
+ * ```
+ */
+const createSiblingExternalizePlugin = (input) => {
+    const { selfSrcPath, selfDtsPath, siblings } = input;
+    const selfEntry = { srcPath: selfSrcPath, indexDtsPath: selfDtsPath };
+    const ownershipPool = [selfEntry, ...siblings];
+    const selfDtsResolved = normalizeToForwardSlashes(selfDtsPath);
+    return {
+        name: 'externalize-sibling-subpaths',
+        resolveId(source, importer) {
+            if (siblings.length === 0)
+                return null;
+            const candidate = resolveCandidate(source, importer, selfDtsPath);
+            const indexCandidate = candidate.endsWith('.d.ts') ? candidate : `${stripTrailingIndexDts(candidate)}/index.d.ts`;
+            const owner = findOwningSibling(candidate, ownershipPool) ?? findOwningSibling(indexCandidate, ownershipPool);
+            if (!owner)
+                return null;
+            if (normalizeToForwardSlashes(owner.indexDtsPath) === selfDtsResolved)
+                return null;
+            return { id: computeSiblingSpecifier(selfDtsPath, owner), external: true };
+        },
+    };
+};
+
+const BYTES_PER_MB = 1024 * 1024;
+const SUPPRESSED_WARNING_CODES = new Set([
+    'CIRCULAR_DEPENDENCY',
+    'UNRESOLVED_IMPORT',
+    'EMPTY_BUNDLE',
+    'UNUSED_EXTERNAL_IMPORT',
+    'MIXED_EXPORTS',
+]);
+/**
+ * Suppresses `MISSING_EXPORT` warnings caused by a package augmenting a
+ * DefinitelyTyped (`@types/*`) module to add members absent from the published
+ * stub. `rollup-plugin-dts` resolves e.g. `import * as estree from 'estree'` to
+ * `@types/estree` but cannot follow the `declare module 'estree'` augmentation
+ * (rollup's own `rollup.d.ts` adds `Decorator` this way) across the external
+ * boundary, so it reports the augmented members as not exported. The
+ * augmentation still resolves correctly in the emitted d.ts, so the warning is
+ * noise during the d.ts pre-pass.
+ *
+ * @param warning - The rollup log entry.
+ * @returns `true` when the warning is a `@types/*` augmentation false positive.
+ */
+const isTypesAugmentationMiss = (warning) => warning.code === 'MISSING_EXPORT' && typeof warning.exporter === 'string' && warning.exporter.includes('/@types/');
+/**
+ * Shared rollup `onwarn` handler for every pre-pass job. Drops the known-benign
+ * warning classes that bundling third-party / workspace deps routinely emits
+ * (see {@link SUPPRESSED_WARNING_CODES} and {@link isTypesAugmentationMiss}) and
+ * forwards everything else to rollup's default handler.
+ *
+ * @param warning - The rollup log entry.
+ * @param defaultHandler - Rollup's default warning handler.
+ *
+ * @example Wiring the handler into a rollup config
+ * ```typescript
+ * const config: RollupOptions = { input, plugins, onwarn: onWarn }
+ * ```
+ */
+const onWarn = (warning, defaultHandler) => {
+    if (warning.code && SUPPRESSED_WARNING_CODES.has(warning.code))
+        return;
+    if (isTypesAugmentationMiss(warning))
+        return;
+    defaultHandler(warning);
+};
+const matchesAnyDep = (id, deps) => {
+    for (const d of deps) {
+        if (id === d || id.startsWith(`${d}/`))
+            return true;
+    }
+    return false;
+};
+const matchesAnyExactSpecifier = (id, specifiers) => {
+    if (!specifiers || specifiers.length === 0)
+        return false;
+    for (const s of specifiers) {
+        if (id === s)
+            return true;
+    }
+    return false;
+};
+/**
+ * Packages whose JS implementation is intentionally NOT inlined during the JS pre-pass.
+ *
+ * Mirrors `ALWAYS_EXTERNAL_TYPE_DEPS` for the JS half. `typescript` is permanent
+ * consumer-supplied — both `@rollup/plugin-typescript` and `rollup-plugin-dts`
+ * follow `require('typescript')` into the compiler; without this gate, ~30 MB
+ * of typescript bytecode ends up inlined into `_dependencies/<plugin>/index.<fmt>.js`.
+ */
+const ALWAYS_EXTERNAL_JS_DEPS = new Set(['typescript']);
+const isExternalJsDep = (id) => {
+    for (const name of ALWAYS_EXTERNAL_JS_DEPS) {
+        if (id === name || id.startsWith(`${name}/`))
+            return true;
+    }
+    return false;
+};
+/**
+ * Builds the canonical externalize plugin for a pre-pass job when the parent
+ * supplied npm deps or workspace routes. Mirrors the plugin install on the
+ * per-entry rollup side so chunk-internal cross-bundled-dep specifiers get
+ * rewritten to relative paths under `_dependencies/` instead of leaking as bare
+ * `require('@hyperfrontend/...')` calls into the published artifact.
+ *
+ * @param job - Pre-pass job spec; only `npmDeps`, `workspaceRoutes`, `depsRoot`, and `outputPath` are read here.
+ * @param format - Output format the plugin should rewrite specifiers for (`'esm'`, `'cjs'`, or `'dts'`).
+ * @returns The plugin when routing data is supplied, or `undefined` to opt out of rewriting.
+ */
+const maybeExternalizePlugin = (job, format) => {
+    const npmDeps = job.npmDeps ?? [];
+    const workspaceRoutes = job.workspaceRoutes ?? [];
+    if (npmDeps.length === 0 && workspaceRoutes.length === 0)
+        return undefined;
+    if (!job.depsRoot)
+        return undefined;
+    return createExternalizeBundledDepsPlugin({
+        deps: npmDeps,
+        entryOutDir: node_path.dirname(job.outputPath),
+        format,
+        depsRoot: job.depsRoot,
+        workspaceRoutes,
+    });
+};
+const buildJsConfig = (job) => {
+    const plugins = [];
+    const externalizePlugin = maybeExternalizePlugin(job, job.format);
+    const hasExternalize = externalizePlugin !== undefined;
+    if (externalizePlugin)
+        plugins.push(externalizePlugin);
+    plugins.push(json__default.default(), nodeResolve__default.default({ preferBuiltins: true, extensions: ['.mjs', '.js', '.cjs', '.json'] }), commonjs__default.default({ ignoreDynamicRequires: true }));
+    return {
+        input: job.inputPath,
+        // why: when the externalize plugin is active, it owns rewriting of bundled-dep specifiers to relative paths under depsRoot. The `external` callback must not short-circuit those — rollup consults `external` before plugin resolveId can run, so any matchesAnyDep hit there leaks bare specifiers into the chunk.
+        external: (id) => node_module.isBuiltin(id) || id.startsWith('node:') || (!hasExternalize && matchesAnyDep(id, job.otherDeps)) || isExternalJsDep(id),
+        onwarn: onWarn,
+        plugins,
+    };
+};
+const requireWorkspaceField = (job, field) => {
+    const value = job[field];
+    if (!value) {
+        throw new Error(`workspace pre-pass job for ${job.dep} (${job.kind}/${job.format}) missing ${field}`);
+    }
+    return value;
+};
+/**
+ * Builds a JS rollup config for a workspace-source pre-pass. The input is a
+ * `.ts` source file; `@rollup/plugin-typescript` transpiles it (and any
+ * transitive workspace files reached via tsconfig path-mapping) while sibling
+ * pre-passed specifiers stay external so each chunk is self-contained.
+ *
+ * The plugin is driven by the dep's own tsconfig (resolved by the parent and
+ * passed through `job.tsConfigPath`), keeping the workspace pre-pass agnostic
+ * of any workspace-root tsconfig.
+ *
+ * @param job - Pre-pass job spec with `tsConfigPath` and `workspaceRoot` populated.
+ * @returns Rollup options ready for the worker to invoke.
+ */
+const buildWorkspaceJsConfig = (job) => {
+    const tsConfigPath = requireWorkspaceField(job, 'tsConfigPath');
+    const workspaceRoot = requireWorkspaceField(job, 'workspaceRoot');
+    const tsPlugin = typescript__default.default({
+        tsconfig: tsConfigPath,
+        declaration: false,
+        declarationMap: false,
+        sourceMap: false,
+        compilerOptions: {
+            baseUrl: workspaceRoot,
+            outDir: node_path.dirname(job.outputPath),
+            noEmitOnError: false,
+            noEmit: false,
+            module: 'esnext',
+        },
+    });
+    const plugins = [];
+    const externalizePlugin = maybeExternalizePlugin(job, job.format);
+    const hasExternalize = externalizePlugin !== undefined;
+    if (externalizePlugin)
+        plugins.push(externalizePlugin);
+    plugins.push(json__default.default(), nodeResolve__default.default({ preferBuiltins: true, extensions: ['.ts', '.mjs', '.js', '.cjs', '.json'] }), commonjs__default.default({ ignoreDynamicRequires: true }), tsPlugin);
+    return {
+        input: job.inputPath,
+        external: (id) => node_module.isBuiltin(id) ||
+            id.startsWith('node:') ||
+            (!hasExternalize && matchesAnyDep(id, job.otherDeps)) ||
+            (!hasExternalize && matchesAnyExactSpecifier(id, job.otherWorkspaceSpecifiers)) ||
+            isExternalJsDep(id),
+        onwarn: onWarn,
+        plugins,
+    };
+};
+const buildJsOutput = (job) => ({
+    file: job.outputPath,
+    format: job.format === 'esm' ? 'esm' : 'cjs',
+    sourcemap: false,
+    inlineDynamicImports: true,
+    exports: 'auto',
+    generatedCode: { constBindings: true },
+});
+/**
+ * Packages whose `.d.ts` is intentionally NOT inlined during the d.ts pre-pass.
+ *
+ * `typescript` is a permanent consumer requirement — never bundled, never inlined,
+ * never copied into `_dependencies/`. The compiler is too large (~10 MB just for
+ * `lib/typescript.d.ts`), its namespace re-exports defeat `rollup-plugin-dts`,
+ * and every consumer of `@hyperfrontend/builder` is, by definition, already a
+ * TypeScript project. Emitted `.d.ts` keeps `import type ... from 'typescript'`
+ * intact so the consumer's own install satisfies the type imports.
+ */
+const ALWAYS_EXTERNAL_TYPE_DEPS = new Set(['typescript']);
+const isExternalTypeDep = (id) => {
+    for (const name of ALWAYS_EXTERNAL_TYPE_DEPS) {
+        if (id === name || id.startsWith(`${name}/`))
+            return true;
+    }
+    return false;
+};
+const loadDtsFactory = async () => {
+    const dtsModule = await import('../../_dependencies/rollup-plugin-dts/index.cjs.js');
+    /* istanbul ignore next -- @preserve fallback path for CJS-style rollup-plugin-dts module shapes */
+    return (dtsModule.default ?? dtsModule);
+};
+const maybeSiblingPlugin = (job) => {
+    if (!job.siblingEntries || job.siblingEntries.length === 0 || !job.selfDtsPath)
+        return undefined;
+    return createSiblingExternalizePlugin({
+        selfSrcPath: job.selfSrcPath ?? '',
+        selfDtsPath: job.selfDtsPath,
+        siblings: job.siblingEntries,
+    });
+};
+const buildDtsConfig = async (job) => {
+    const dtsFactory = await loadDtsFactory();
+    const plugins = [];
+    const siblingPlugin = maybeSiblingPlugin(job);
+    if (siblingPlugin)
+        plugins.push(siblingPlugin);
+    const externalizePlugin = maybeExternalizePlugin(job, 'dts');
+    const hasExternalize = externalizePlugin !== undefined;
+    if (externalizePlugin)
+        plugins.push(externalizePlugin);
+    plugins.push(dtsFactory({ respectExternal: true }));
+    return {
+        input: job.inputPath,
+        external: (id) => node_module.isBuiltin(id) || id.startsWith('node:') || (!hasExternalize && matchesAnyDep(id, job.otherDeps)) || isExternalTypeDep(id),
+        onwarn: onWarn,
+        plugins,
+    };
+};
+/**
+ * Builds a d.ts rollup config for a workspace-source pre-pass. The input is a
+ * `.ts` source file; `rollup-plugin-dts` drives TypeScript using the project's
+ * tsconfig so workspace path-mappings resolve and transitive type imports are
+ * properly inlined or externalized.
+ *
+ * @param job - Pre-pass job spec with `tsConfigPath` and `workspaceRoot` populated.
+ * @returns Rollup options ready for the worker to invoke.
+ */
+const buildWorkspaceDtsConfig = async (job) => {
+    const tsConfigPath = requireWorkspaceField(job, 'tsConfigPath');
+    const workspaceRoot = requireWorkspaceField(job, 'workspaceRoot');
+    const dtsFactory = await loadDtsFactory();
+    const plugins = [];
+    const externalizePlugin = maybeExternalizePlugin(job, 'dts');
+    const hasExternalize = externalizePlugin !== undefined;
+    if (externalizePlugin)
+        plugins.push(externalizePlugin);
+    plugins.push(dtsFactory({ respectExternal: true, tsconfig: tsConfigPath, compilerOptions: { baseUrl: workspaceRoot } }));
+    return {
+        input: job.inputPath,
+        external: (id) => node_module.isBuiltin(id) ||
+            id.startsWith('node:') ||
+            (!hasExternalize && matchesAnyDep(id, job.otherDeps)) ||
+            (!hasExternalize && matchesAnyExactSpecifier(id, job.otherWorkspaceSpecifiers)) ||
+            isExternalTypeDep(id),
+        onwarn: onWarn,
+        plugins,
+    };
+};
+const buildDtsOutput = (job) => ({
+    file: job.outputPath,
+    format: 'es',
+    sourcemap: false,
+    inlineDynamicImports: true,
+});
+const ensureParentDir = (filePath) => {
+    node_fs.mkdirSync(node_path.dirname(filePath), { recursive: true });
+};
+const buildConfigForJob = async (job) => {
+    switch (job.kind) {
+        case 'dts':
+            return buildDtsConfig(job);
+        case 'workspace-js':
+            return buildWorkspaceJsConfig(job);
+        case 'workspace-dts':
+            return buildWorkspaceDtsConfig(job);
+        default:
+            return buildJsConfig(job);
+    }
+};
+/**
+ * Runs a single pre-pass rollup invocation as described by `job` and writes the
+ * resulting report to `job.reportPath`.
+ *
+ * Public so callers (and tests) can drive the worker logic without spawning a
+ * new Node process.
+ *
+ * @param job - Job spec describing the rollup invocation.
+ * @returns The on-disk report data the worker would have persisted.
+ *
+ * @example Driving the worker logic in-process for a fixture
+ * ```typescript
+ * const report = await runPrePassWorkerJob({ kind: 'js', dep: 'rollup', ... })
+ * ```
+ */
+const runPrePassWorkerJob = async (job) => {
+    const startedAt = Date.now();
+    ensureParentDir(job.outputPath);
+    ensureParentDir(job.reportPath);
+    const config = await buildConfigForJob(job);
+    const output = job.kind === 'dts' || job.kind === 'workspace-dts' ? buildDtsOutput(job) : buildJsOutput(job);
+    const bundle = await index_cjs_js$b.rollup(config);
+    try {
+        await bundle.write(output);
+    }
+    finally {
+        await bundle.close();
+    }
+    const memory = process.memoryUsage();
+    const report = {
+        outputSize: node_fs.statSync(job.outputPath).size,
+        endHeapMB: memory.heapUsed / BYTES_PER_MB,
+        endRssMB: memory.rss / BYTES_PER_MB,
+        durationMs: Date.now() - startedAt,
+    };
+    node_fs.writeFileSync(job.reportPath, JSON.stringify(report));
+    return report;
+};
+
+const isMainModule = () => {
+    if (typeof require !== 'undefined' && typeof module !== 'undefined' && require.main === module) {
+        return true;
+    }
+    const argv1 = process.argv[1] ?? '';
+    return argv1.endsWith('index.cjs.js') || argv1.endsWith('index.esm.js') || argv1.endsWith('index.ts') || argv1.endsWith('index.js');
+};
+if (isMainModule()) {
+    const raw = process.argv[2];
+    if (!raw) {
+        process.stderr.write('pre-pass worker: missing job spec on argv\n');
+        process.exit(2);
+    }
+    const job = JSON.parse(raw);
+    runPrePassWorkerJob(job).then(() => process.exit(0), (error) => {
+        const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+        process.stderr.write(`pre-pass worker for ${job.dep}/${job.kind}/${job.format} failed: ${message}\n`);
+        process.exit(1);
+    });
+}
+
+exports.buildWorkspaceRoutes = buildWorkspaceRoutes;
+exports.createExternalizeBundledDepsPlugin = createExternalizeBundledDepsPlugin;
+exports.loadWorkspacePathMappings = loadWorkspacePathMappings;
+exports.relativeImport = relativeImport;
+exports.resolveBundledDeps = resolveBundledDeps;
+exports.resolveDefaultWorkerPath = resolveDefaultWorkerPath;
+exports.resolveWorkspaceBundledDeps = resolveWorkspaceBundledDeps;
+exports.runPrePass = runPrePass;
+exports.runPrePassWorkerJob = runPrePassWorkerJob;