@hyperfrontend/builder 0.1.0

package/bundle/dependencies/resolve-workspace-bundled-deps.d.ts

@@ -0,0 +1,96 @@
+import type { IsWorkspacePackagePredicate, WorkspaceDepHoistPolicy } from '../../models';
+/**
+ * Resolved workspace-dep pre-pass entry.
+ */
+export interface ResolvedWorkspaceDepEntry {
+    /** Workspace package name, e.g. `@hyperfrontend/logging`. */
+    packageName: string;
+    /** Sub-path under the package; `''` when the entry is the package root. */
+    subPath: string;
+    /** Public import specifier this entry resolves: `<packageName>` or `<packageName>/<subPath>`. */
+    specifier: string;
+    /** Absolute path to the source file (from tsconfig path-mapping). */
+    inputPath: string;
+    /** Absolute path to the dep's own tsconfig used by `@rollup/plugin-typescript` during pre-pass. */
+    tsConfigPath: string;
+    /** Hoist policy applied to this entry's package; carried through so callers need not re-derive it. */
+    policy: WorkspaceDepHoistPolicy;
+}
+/**
+ * Inputs to {@link resolveWorkspaceBundledDeps}.
+ */
+export interface ResolveWorkspaceBundledDepsOptions {
+    /** Predicate identifying workspace-internal packages. */
+    isWorkspacePackage: IsWorkspacePackagePredicate;
+    /** Force-include packages even if absent from `package.json#dependencies`. */
+    include?: string[];
+    /** Skip these packages even if otherwise selected. */
+    exclude?: string[];
+    /**
+     * Per-package hoist-policy override, keyed by package name. Packages absent
+     * from the map default to `'sub-path'` (granular, zero-config). Set a package
+     * to `'whole-surface'` to opt into collapsing its sub-paths onto the root
+     * chunk. No built-in entries; callers supply their own opinions.
+     */
+    policy?: Record<string, WorkspaceDepHoistPolicy>;
+}
+/**
+ * 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']
+ * ```
+ */
+export declare const loadWorkspacePathMappings: (workspaceRoot: string) => Map<string, string[]>;
+/**
+ * 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/') }
+ * )
+ * ```
+ */
+export declare const resolveWorkspaceBundledDeps: (packageJsonPath: string, workspaceRoot: string, options: ResolveWorkspaceBundledDepsOptions) => ResolvedWorkspaceDepEntry[];
+//# sourceMappingURL=resolve-workspace-bundled-deps.d.ts.map

package/bundle/dependencies/resolve-workspace-bundled-deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-workspace-bundled-deps.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/dependencies/resolve-workspace-bundled-deps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAe,uBAAuB,EAAE,MAAM,cAAc,CAAA;AAUrG;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAA;IACnB,2EAA2E;IAC3E,OAAO,EAAE,MAAM,CAAA;IACf,iGAAiG;IACjG,SAAS,EAAE,MAAM,CAAA;IACjB,qEAAqE;IACrE,SAAS,EAAE,MAAM,CAAA;IACjB,mGAAmG;IACnG,YAAY,EAAE,MAAM,CAAA;IACpB,sGAAsG;IACtG,MAAM,EAAE,uBAAuB,CAAA;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,kCAAkC;IACjD,yDAAyD;IACzD,kBAAkB,EAAE,2BAA2B,CAAA;IAC/C,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAA;CACjD;AAsED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,yBAAyB,GAAI,eAAe,MAAM,KAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAQrF,CAAA;AAoGD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,eAAO,MAAM,2BAA2B,GACtC,iBAAiB,MAAM,EACvB,eAAe,MAAM,EACrB,SAAS,kCAAkC,KAC1C,yBAAyB,EA4D3B,CAAA"}

package/bundle/dependencies/worker/index.cjs.js

@@ -0,0 +1,524 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const node_module = require('node:module');
+const node_path = require('node:path');
+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 = require('../../../_dependencies/rollup/index.cjs.js');
+const { normalizeToForwardSlashes, join } = require('../../../_shared/bundle/fs/posix-path/index.cjs.js');
+const { 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 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.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.runPrePassWorkerJob = runPrePassWorkerJob;