@hyperfrontend/builder 0.1.0

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

@@ -0,0 +1,115 @@
+import type { RollupLog } from 'rollup';
+import type { SiblingEntry } from '../../declarations/sibling-resolver';
+import type { WorkspaceBundledDepRoute } from '../externalize-plugin';
+/**
+ * Pre-pass kinds. `js` and `dts` cover npm bundled deps with pre-built JS and
+ * `.d.ts` entries; `workspace-js` and `workspace-dts` cover workspace
+ * `@hyperfrontend/*` deps whose entries are TypeScript source and require
+ * type-aware transformation against the workspace tsconfig.
+ */
+export type PrePassWorkerJobKind = 'js' | 'dts' | 'workspace-js' | 'workspace-dts';
+/**
+ * Job spec consumed by the pre-pass worker via `process.argv[2]`.
+ *
+ * Each invocation produces exactly one rollup output and one JSON report at
+ * `reportPath` so the parent orchestrator can collect per-job statistics.
+ */
+export interface PrePassWorkerJob {
+    /**
+     * Pre-pass kind. `js` and `dts` run the npm-dep pipeline; `workspace-js` and
+     * `workspace-dts` add `@rollup/plugin-typescript` (or `rollup-plugin-dts`'s
+     * tsconfig integration) so TypeScript source workspace deps can be hoisted.
+     */
+    kind: PrePassWorkerJobKind;
+    /** Dep package name (or workspace specifier) being pre-passed. */
+    dep: string;
+    /** Absolute path to the dep's entry (main / module for JS, types for dts, source `.ts` for workspace-*). */
+    inputPath: string;
+    /** Output format. JS jobs must use `'esm'` or `'cjs'`. dts jobs always use `'es'` internally. */
+    format: 'esm' | 'cjs';
+    /** Absolute path to the output file. */
+    outputPath: string;
+    /** Other deps in the pre-pass set; marked external so cross-dep imports stay link-time. Prefix-matched. */
+    otherDeps: string[];
+    /**
+     * Sub-path-mode workspace specifiers in the pre-pass set; matched as exact
+     * specifier only (e.g. `@hyperfrontend/immutable-api-utils/built-in-copy/array`).
+     * Used by `workspace-*` jobs so sibling sub-paths externalize cleanly without
+     * also externalizing every other sub-path on the same package.
+     */
+    otherWorkspaceSpecifiers?: string[];
+    /** Absolute path to the project's tsconfig (workspace-* jobs only). */
+    tsConfigPath?: string;
+    /** Absolute workspace root used as `baseUrl` for path-mapping resolution (workspace-* jobs only). */
+    workspaceRoot?: string;
+    /**
+     * Sibling-entry descriptors used by the per-entry `dts` pass to externalize
+     * imports that resolve into another entry's directory. Empty / omitted for
+     * dep pre-pass jobs.
+     */
+    siblingEntries?: SiblingEntry[];
+    /** Absolute path to the input file's owning entry directory (used to compute sibling specifiers). */
+    selfDtsPath?: string;
+    /** Owning entry's `srcPath` (used for diagnostics). Empty string for the package root. */
+    selfSrcPath?: string;
+    /**
+     * NPM bundled-dep names consumed by the canonical externalize plugin to rewrite
+     * cross-dep imports to relative paths under {@link depsRoot}.
+     */
+    npmDeps?: string[];
+    /**
+     * Workspace bundled-dep routes consumed by the canonical externalize plugin.
+     * For self-pre-pass jobs (`workspace-js` / `workspace-dts`) this excludes the
+     * specifier or package being built so the chunk inlines its own internals.
+     */
+    workspaceRoutes?: WorkspaceBundledDepRoute[];
+    /** Absolute path to the project's `_dependencies/` root. Required when {@link npmDeps} or {@link workspaceRoutes} is non-empty. */
+    depsRoot?: string;
+    /** Absolute path where the worker writes its JSON report. */
+    reportPath: string;
+}
+/**
+ * Memory + size summary written to `reportPath` when a worker exits cleanly.
+ */
+export interface PrePassWorkerReport {
+    /** Final on-disk size of the rollup output, in bytes. */
+    outputSize: number;
+    /** `process.memoryUsage().heapUsed` in MB at end of bundle. */
+    endHeapMB: number;
+    /** `process.memoryUsage().rss` in MB at end of bundle. */
+    endRssMB: number;
+    /** Worker wall-clock duration in ms. */
+    durationMs: number;
+}
+/**
+ * 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 }
+ * ```
+ */
+export declare const onWarn: (warning: RollupLog, defaultHandler: (w: RollupLog) => void) => void;
+/**
+ * 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', ... })
+ * ```
+ */
+export declare const runPrePassWorkerJob: (job: PrePassWorkerJob) => Promise<PrePassWorkerReport>;
+//# sourceMappingURL=job-runner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"job-runner.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/worker/job-runner.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAyB,SAAS,EAAiB,MAAM,QAAQ,CAAA;AAC7E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAA;AACvE,OAAO,KAAK,EAAqB,wBAAwB,EAAE,MAAM,uBAAuB,CAAA;AAYxF;;;;;GAKG;AACH,MAAM,MAAM,oBAAoB,GAAG,IAAI,GAAG,KAAK,GAAG,cAAc,GAAG,eAAe,CAAA;AAElF;;;;;GAKG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,IAAI,EAAE,oBAAoB,CAAA;IAC1B,kEAAkE;IAClE,GAAG,EAAE,MAAM,CAAA;IACX,4GAA4G;IAC5G,SAAS,EAAE,MAAM,CAAA;IACjB,iGAAiG;IACjG,MAAM,EAAE,KAAK,GAAG,KAAK,CAAA;IACrB,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAA;IAClB,2GAA2G;IAC3G,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB;;;;;OAKG;IACH,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAA;IACnC,uEAAuE;IACvE,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,qGAAqG;IACrG,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;OAIG;IACH,cAAc,CAAC,EAAE,YAAY,EAAE,CAAA;IAC/B,qGAAqG;IACrG,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,0FAA0F;IAC1F,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB;;;;OAIG;IACH,eAAe,CAAC,EAAE,wBAAwB,EAAE,CAAA;IAC5C,mIAAmI;IACnI,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,6DAA6D;IAC7D,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,yDAAyD;IACzD,UAAU,EAAE,MAAM,CAAA;IAClB,+DAA+D;IAC/D,SAAS,EAAE,MAAM,CAAA;IACjB,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,CAAA;IAChB,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAA;CACnB;AA4BD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,MAAM,GAAI,SAAS,SAAS,EAAE,gBAAgB,CAAC,CAAC,EAAE,SAAS,KAAK,IAAI,KAAG,IAInF,CAAA;AAuSD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,GAAU,KAAK,gBAAgB,KAAG,OAAO,CAAC,mBAAmB,CAqB5F,CAAA"}

package/bundle/entries/by-platform.d.ts

@@ -0,0 +1,27 @@
+import type { EntryPoint, EntryPointDiscovery, EntryPointPlatform } from '../../models';
+/**
+ * Returns the entry points belonging to the requested platform.
+ *
+ * @param discovery - Discovery result returned by `discoverEntries`.
+ * @param platform - Platform hint to filter on.
+ * @returns Subset of `discovery.entryPoints` flagged with the matching platform.
+ *
+ * @example Retrieving browser entries
+ * ```typescript
+ * const browserEntries = getEntriesByPlatform(discovery, 'browser')
+ * ```
+ */
+export declare const getEntriesByPlatform: (discovery: EntryPointDiscovery, platform: EntryPointPlatform) => EntryPoint[];
+/**
+ * Returns the entry points that have no platform hint (root and shared/feature entries).
+ *
+ * @param discovery - Discovery result returned by `discoverEntries`.
+ * @returns Subset of `discovery.entryPoints` without a platform hint.
+ *
+ * @example Retrieving the shared / non-platform entries
+ * ```typescript
+ * const shared = getSharedEntries(discovery)
+ * ```
+ */
+export declare const getSharedEntries: (discovery: EntryPointDiscovery) => EntryPoint[];
+//# sourceMappingURL=by-platform.d.ts.map

package/bundle/entries/by-platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"by-platform.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/entries/by-platform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAEvF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,oBAAoB,GAAI,WAAW,mBAAmB,EAAE,UAAU,kBAAkB,KAAG,UAAU,EACxC,CAAA;AAEtE;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,GAAI,WAAW,mBAAmB,KAAG,UAAU,EAA8D,CAAA"}

package/bundle/entries/discover-entries.d.ts

@@ -0,0 +1,24 @@
+import type { EntryPointDiscovery } from '../../models';
+/**
+ * Discovers every entry point exposed by a library project.
+ *
+ * Scans `<projectRoot>/src` for the root `index.ts` plus every nested directory
+ * containing an `index.ts`. Recognized layouts include:
+ *
+ * - `src/index.ts` — root entry
+ * - `src/browser/index.ts`, `src/node/index.ts` — platform entries
+ * - `src/<feature>/index.ts` — feature entries
+ * - `src/<platform>/<feature>/index.ts` — nested entries (max depth 3)
+ *
+ * @param projectRoot - Absolute path to the project root.
+ * @returns Discovery result containing every entry point with its layout category.
+ *
+ * @example Discovering entries for a barrel library
+ * ```typescript
+ * const discovery = discoverEntries('/abs/path/to/libs/utils')
+ * discovery.category   // => 'feature' | 'platform' | 'hybrid' | ...
+ * discovery.entryPoints // => [{ exportPath: '.', ... }, ...]
+ * ```
+ */
+export declare const discoverEntries: (projectRoot: string) => EntryPointDiscovery;
+//# sourceMappingURL=discover-entries.d.ts.map

package/bundle/entries/discover-entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discover-entries.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/entries/discover-entries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkC,mBAAmB,EAAsB,MAAM,cAAc,CAAA;AAwD3G;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,eAAe,GAAI,aAAa,MAAM,KAAG,mBA4BrD,CAAA"}

package/bundle/entries/index.cjs.js

@@ -0,0 +1,38 @@
+'use strict';
+
+const index_cjs_js = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.cjs.js');
+const index_cjs_js$1 = require('../../_dependencies/@hyperfrontend/project-scope/core/index.cjs.js');
+const index_cjs_js$2 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.cjs.js');
+const { discoverEntries } = require('../../_shared/bundle/entries/discover-entries/index.cjs.js');
+const { resolveEntries } = require('../../_shared/bundle/entries/resolve-entries/index.cjs.js');
+
+/**
+ * Returns the entry points belonging to the requested platform.
+ *
+ * @param discovery - Discovery result returned by `discoverEntries`.
+ * @param platform - Platform hint to filter on.
+ * @returns Subset of `discovery.entryPoints` flagged with the matching platform.
+ *
+ * @example Retrieving browser entries
+ * ```typescript
+ * const browserEntries = getEntriesByPlatform(discovery, 'browser')
+ * ```
+ */
+const getEntriesByPlatform = (discovery, platform) => discovery.entryPoints.filter((entry) => entry.platform === platform);
+/**
+ * Returns the entry points that have no platform hint (root and shared/feature entries).
+ *
+ * @param discovery - Discovery result returned by `discoverEntries`.
+ * @returns Subset of `discovery.entryPoints` without a platform hint.
+ *
+ * @example Retrieving the shared / non-platform entries
+ * ```typescript
+ * const shared = getSharedEntries(discovery)
+ * ```
+ */
+const getSharedEntries = (discovery) => discovery.entryPoints.filter((entry) => !entry.platform);
+
+exports.discoverEntries = discoverEntries;
+exports.getEntriesByPlatform = getEntriesByPlatform;
+exports.getSharedEntries = getSharedEntries;
+exports.resolveEntries = resolveEntries;

package/bundle/entries/index.d.ts

@@ -0,0 +1,70 @@
+import { EntryPointDiscovery, EntryPointPlatform, EntryPoint, FormatEntryConfig } from '../../models';
+
+/**
+ * Returns the entry points belonging to the requested platform.
+ *
+ * @param discovery - Discovery result returned by `discoverEntries`.
+ * @param platform - Platform hint to filter on.
+ * @returns Subset of `discovery.entryPoints` flagged with the matching platform.
+ *
+ * @example Retrieving browser entries
+ * ```typescript
+ * const browserEntries = getEntriesByPlatform(discovery, 'browser')
+ * ```
+ */
+declare const getEntriesByPlatform: (discovery: EntryPointDiscovery, platform: EntryPointPlatform) => EntryPoint[];
+/**
+ * Returns the entry points that have no platform hint (root and shared/feature entries).
+ *
+ * @param discovery - Discovery result returned by `discoverEntries`.
+ * @returns Subset of `discovery.entryPoints` without a platform hint.
+ *
+ * @example Retrieving the shared / non-platform entries
+ * ```typescript
+ * const shared = getSharedEntries(discovery)
+ * ```
+ */
+declare const getSharedEntries: (discovery: EntryPointDiscovery) => EntryPoint[];
+
+/**
+ * Discovers every entry point exposed by a library project.
+ *
+ * Scans `<projectRoot>/src` for the root `index.ts` plus every nested directory
+ * containing an `index.ts`. Recognized layouts include:
+ *
+ * - `src/index.ts` — root entry
+ * - `src/browser/index.ts`, `src/node/index.ts` — platform entries
+ * - `src/<feature>/index.ts` — feature entries
+ * - `src/<platform>/<feature>/index.ts` — nested entries (max depth 3)
+ *
+ * @param projectRoot - Absolute path to the project root.
+ * @returns Discovery result containing every entry point with its layout category.
+ *
+ * @example Discovering entries for a barrel library
+ * ```typescript
+ * const discovery = discoverEntries('/abs/path/to/libs/utils')
+ * discovery.category   // => 'feature' | 'platform' | 'hybrid' | ...
+ * discovery.entryPoints // => [{ exportPath: '.', ... }, ...]
+ * ```
+ */
+declare const discoverEntries: (projectRoot: string) => EntryPointDiscovery;
+
+/**
+ * Filters discovered entry points using a `FormatEntryConfig`'s
+ * `entry` and `exclude` patterns.
+ *
+ * Patterns may be exact subpaths (`./browser`), globs (`./browser/*`), or arrays of either.
+ * When `entry` is omitted every discovered entry is considered, then `exclude` removes matches.
+ *
+ * @param config - Format-level entry configuration.
+ * @param discoveredEntries - Entry points returned by `discoverEntries`.
+ * @returns Filtered entry points in their original order.
+ *
+ * @example Selecting only browser entries
+ * ```typescript
+ * resolveEntries({ entry: './browser/*' }, discovery.entryPoints)
+ * ```
+ */
+declare const resolveEntries: (config: FormatEntryConfig, discoveredEntries: EntryPoint[]) => EntryPoint[];
+
+export { discoverEntries, getEntriesByPlatform, getSharedEntries, resolveEntries };

package/bundle/entries/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/entries/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AACtE,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAA;AACpD,OAAO,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAA"}

package/bundle/entries/index.esm.js

@@ -0,0 +1,33 @@
+import { freeze } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.esm.js';
+import { join, exists, isDirectory, readDirectory, matchGlobPattern } from '../../_dependencies/@hyperfrontend/project-scope/core/index.esm.js';
+import { isArray } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.esm.js';
+import { discoverEntries } from '../../_shared/bundle/entries/discover-entries/index.esm.js';
+import { resolveEntries } from '../../_shared/bundle/entries/resolve-entries/index.esm.js';
+
+/**
+ * Returns the entry points belonging to the requested platform.
+ *
+ * @param discovery - Discovery result returned by `discoverEntries`.
+ * @param platform - Platform hint to filter on.
+ * @returns Subset of `discovery.entryPoints` flagged with the matching platform.
+ *
+ * @example Retrieving browser entries
+ * ```typescript
+ * const browserEntries = getEntriesByPlatform(discovery, 'browser')
+ * ```
+ */
+const getEntriesByPlatform = (discovery, platform) => discovery.entryPoints.filter((entry) => entry.platform === platform);
+/**
+ * Returns the entry points that have no platform hint (root and shared/feature entries).
+ *
+ * @param discovery - Discovery result returned by `discoverEntries`.
+ * @returns Subset of `discovery.entryPoints` without a platform hint.
+ *
+ * @example Retrieving the shared / non-platform entries
+ * ```typescript
+ * const shared = getSharedEntries(discovery)
+ * ```
+ */
+const getSharedEntries = (discovery) => discovery.entryPoints.filter((entry) => !entry.platform);
+
+export { discoverEntries, getEntriesByPlatform, getSharedEntries, resolveEntries };

package/bundle/entries/resolve-entries.d.ts

@@ -0,0 +1,19 @@
+import type { EntryPoint, FormatEntryConfig } from '../../models';
+/**
+ * Filters discovered entry points using a `FormatEntryConfig`'s
+ * `entry` and `exclude` patterns.
+ *
+ * Patterns may be exact subpaths (`./browser`), globs (`./browser/*`), or arrays of either.
+ * When `entry` is omitted every discovered entry is considered, then `exclude` removes matches.
+ *
+ * @param config - Format-level entry configuration.
+ * @param discoveredEntries - Entry points returned by `discoverEntries`.
+ * @returns Filtered entry points in their original order.
+ *
+ * @example Selecting only browser entries
+ * ```typescript
+ * resolveEntries({ entry: './browser/*' }, discovery.entryPoints)
+ * ```
+ */
+export declare const resolveEntries: (config: FormatEntryConfig, discoveredEntries: EntryPoint[]) => EntryPoint[];
+//# sourceMappingURL=resolve-entries.d.ts.map

package/bundle/entries/resolve-entries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-entries.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/entries/resolve-entries.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAmBjE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,iBAAiB,EAAE,mBAAmB,UAAU,EAAE,KAAG,UAAU,EAWrG,CAAA"}

package/bundle/externals/index.cjs.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const index_cjs_js$2 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.cjs.js');
+const index_cjs_js = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.cjs.js');
+const index_cjs_js$1 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/set/index.cjs.js');
+const index_cjs_js$3 = require('../../_dependencies/@hyperfrontend/project-scope/core/fs/index.cjs.js');
+const index_cjs_js$4 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.cjs.js');
+const { validateExternalsConfig } = require('../../_shared/bundle/externals/validate-globals/index.cjs.js');
+
+const readPkg = (packageJsonPath) => (index_cjs_js$3.exists(packageJsonPath) ? index_cjs_js$3.readJsonFile(packageJsonPath) : {});
+/**
+ * Resolves the external package list for a single bundle.
+ *
+ * The output combines:
+ * - top-level `dependencies` from the project's `package.json`
+ * - `peerDependencies` (always external regardless of `bundleWorkspaceDeps`)
+ * - the caller-supplied `additional` list
+ *
+ * When `bundleWorkspaceDeps` is `true` and a workspace predicate is supplied, packages
+ * matching the predicate are stripped from `dependencies` and `additional` so they get
+ * inlined by the bundler. Peer dependencies are always preserved.
+ *
+ * @param options - Inputs controlling the resolution.
+ * @returns Sorted, de-duplicated list of external package names.
+ *
+ * @example Resolving externals while inlining workspace deps
+ * ```typescript
+ * const external = resolveExternals({
+ *   packageJsonPath: '/abs/libs/foo/package.json',
+ *   isWorkspacePackage: (n) => n.startsWith('@hyperfrontend/'),
+ *   bundleWorkspaceDeps: true,
+ * })
+ * ```
+ */
+const resolveExternals = (options) => {
+    const pkg = readPkg(options.packageJsonPath);
+    const deps = index_cjs_js.keys(pkg.dependencies ?? {});
+    const peerDeps = index_cjs_js.keys(pkg.peerDependencies ?? {});
+    const additional = options.additional ?? [];
+    const bundledSet = index_cjs_js$1.createSet(options.bundledDeps ?? []);
+    const workspaceBundledSet = index_cjs_js$1.createSet(options.workspaceBundledDepNames ?? []);
+    const inlineWorkspace = options.bundleWorkspaceDeps === true && options.isWorkspacePackage !== undefined;
+    const filterWorkspace = (names) => inlineWorkspace ? names.filter((n) => !options.isWorkspacePackage(n)) : names;
+    const filterBundled = (names) => (bundledSet.size === 0 ? names : names.filter((n) => !bundledSet.has(n)));
+    const filterWorkspaceBundled = (names) => workspaceBundledSet.size === 0 ? names : names.filter((n) => !workspaceBundledSet.has(n));
+    return index_cjs_js$2.from(index_cjs_js$1.createSet([
+        ...filterWorkspaceBundled(filterBundled(filterWorkspace(deps))),
+        ...filterWorkspaceBundled(filterBundled(peerDeps)),
+        ...filterWorkspaceBundled(filterBundled(filterWorkspace(additional))),
+    ]));
+};
+
+exports.resolveExternals = resolveExternals;
+exports.validateExternalsConfig = validateExternalsConfig;

package/bundle/externals/index.d.ts

@@ -0,0 +1,74 @@
+import { IsWorkspacePackagePredicate } from '../../models';
+
+/**
+ * Inputs to `resolveExternals`.
+ */
+interface ResolveExternalsOptions {
+    /** Absolute path to the project's `package.json`. */
+    packageJsonPath: string;
+    /** Additional package names to mark external regardless of the package.json contents. */
+    additional?: string[];
+    /** Predicate identifying workspace-internal packages. Defaults to "everything is external". */
+    isWorkspacePackage?: IsWorkspacePackagePredicate;
+    /** When `true`, workspace packages are inlined and stripped from the resolved external list. */
+    bundleWorkspaceDeps?: boolean;
+    /**
+     * Third-party package names being bundled into `_dependencies/`. When non-empty,
+     * these are removed from the resolved external list so their imports are routed
+     * to the bundled copies instead of left external.
+     */
+    bundledDeps?: string[];
+    /**
+     * Workspace package names being bundled into `_dependencies/`. When non-empty,
+     * these are removed from the resolved external list so their imports are routed
+     * to the bundled copies instead of left external.
+     */
+    workspaceBundledDepNames?: string[];
+}
+/**
+ * Resolves the external package list for a single bundle.
+ *
+ * The output combines:
+ * - top-level `dependencies` from the project's `package.json`
+ * - `peerDependencies` (always external regardless of `bundleWorkspaceDeps`)
+ * - the caller-supplied `additional` list
+ *
+ * When `bundleWorkspaceDeps` is `true` and a workspace predicate is supplied, packages
+ * matching the predicate are stripped from `dependencies` and `additional` so they get
+ * inlined by the bundler. Peer dependencies are always preserved.
+ *
+ * @param options - Inputs controlling the resolution.
+ * @returns Sorted, de-duplicated list of external package names.
+ *
+ * @example Resolving externals while inlining workspace deps
+ * ```typescript
+ * const external = resolveExternals({
+ *   packageJsonPath: '/abs/libs/foo/package.json',
+ *   isWorkspacePackage: (n) => n.startsWith('@hyperfrontend/'),
+ *   bundleWorkspaceDeps: true,
+ * })
+ * ```
+ */
+declare const resolveExternals: (options: ResolveExternalsOptions) => string[];
+
+/**
+ * Verifies that every external dependency declared for an IIFE / UMD bundle
+ * has a corresponding entry in the supplied `globals` map.
+ *
+ * Throws an aggregated error listing the missing entries when the configuration
+ * is incomplete; resolves silently otherwise.
+ *
+ * @param external - Package names declared as external for the bundle.
+ * @param globals - Mapping of package name to global variable name.
+ * @throws {Error} When at least one external dependency is missing from `globals`.
+ *
+ * @example Failing fast when a globals mapping is missing
+ * ```typescript
+ * validateExternalsConfig(['react'], { 'react-dom': 'ReactDOM' })
+ * // => throws: Missing globals mapping for external dependencies: react
+ * ```
+ */
+declare const validateExternalsConfig: (external: string[] | undefined, globals: Record<string, string> | undefined) => void;
+
+export { resolveExternals, validateExternalsConfig };
+export type { ResolveExternalsOptions };

package/bundle/externals/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/externals/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,YAAY,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAA;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACtD,OAAO,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAA"}

package/bundle/externals/index.esm.js

@@ -0,0 +1,51 @@
+import { from } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.esm.js';
+import { keys } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.esm.js';
+import { createSet } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/set/index.esm.js';
+import { exists, readJsonFile } from '../../_dependencies/@hyperfrontend/project-scope/core/fs/index.esm.js';
+import { createError } from '../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/error/index.esm.js';
+import { validateExternalsConfig } from '../../_shared/bundle/externals/validate-globals/index.esm.js';
+
+const readPkg = (packageJsonPath) => (exists(packageJsonPath) ? readJsonFile(packageJsonPath) : {});
+/**
+ * Resolves the external package list for a single bundle.
+ *
+ * The output combines:
+ * - top-level `dependencies` from the project's `package.json`
+ * - `peerDependencies` (always external regardless of `bundleWorkspaceDeps`)
+ * - the caller-supplied `additional` list
+ *
+ * When `bundleWorkspaceDeps` is `true` and a workspace predicate is supplied, packages
+ * matching the predicate are stripped from `dependencies` and `additional` so they get
+ * inlined by the bundler. Peer dependencies are always preserved.
+ *
+ * @param options - Inputs controlling the resolution.
+ * @returns Sorted, de-duplicated list of external package names.
+ *
+ * @example Resolving externals while inlining workspace deps
+ * ```typescript
+ * const external = resolveExternals({
+ *   packageJsonPath: '/abs/libs/foo/package.json',
+ *   isWorkspacePackage: (n) => n.startsWith('@hyperfrontend/'),
+ *   bundleWorkspaceDeps: true,
+ * })
+ * ```
+ */
+const resolveExternals = (options) => {
+    const pkg = readPkg(options.packageJsonPath);
+    const deps = keys(pkg.dependencies ?? {});
+    const peerDeps = keys(pkg.peerDependencies ?? {});
+    const additional = options.additional ?? [];
+    const bundledSet = createSet(options.bundledDeps ?? []);
+    const workspaceBundledSet = createSet(options.workspaceBundledDepNames ?? []);
+    const inlineWorkspace = options.bundleWorkspaceDeps === true && options.isWorkspacePackage !== undefined;
+    const filterWorkspace = (names) => inlineWorkspace ? names.filter((n) => !options.isWorkspacePackage(n)) : names;
+    const filterBundled = (names) => (bundledSet.size === 0 ? names : names.filter((n) => !bundledSet.has(n)));
+    const filterWorkspaceBundled = (names) => workspaceBundledSet.size === 0 ? names : names.filter((n) => !workspaceBundledSet.has(n));
+    return from(createSet([
+        ...filterWorkspaceBundled(filterBundled(filterWorkspace(deps))),
+        ...filterWorkspaceBundled(filterBundled(peerDeps)),
+        ...filterWorkspaceBundled(filterBundled(filterWorkspace(additional))),
+    ]));
+};
+
+export { resolveExternals, validateExternalsConfig };

package/bundle/externals/resolve-externals.d.ts

@@ -0,0 +1,52 @@
+import type { IsWorkspacePackagePredicate } from '../../models';
+/**
+ * Inputs to `resolveExternals`.
+ */
+export interface ResolveExternalsOptions {
+    /** Absolute path to the project's `package.json`. */
+    packageJsonPath: string;
+    /** Additional package names to mark external regardless of the package.json contents. */
+    additional?: string[];
+    /** Predicate identifying workspace-internal packages. Defaults to "everything is external". */
+    isWorkspacePackage?: IsWorkspacePackagePredicate;
+    /** When `true`, workspace packages are inlined and stripped from the resolved external list. */
+    bundleWorkspaceDeps?: boolean;
+    /**
+     * Third-party package names being bundled into `_dependencies/`. When non-empty,
+     * these are removed from the resolved external list so their imports are routed
+     * to the bundled copies instead of left external.
+     */
+    bundledDeps?: string[];
+    /**
+     * Workspace package names being bundled into `_dependencies/`. When non-empty,
+     * these are removed from the resolved external list so their imports are routed
+     * to the bundled copies instead of left external.
+     */
+    workspaceBundledDepNames?: string[];
+}
+/**
+ * Resolves the external package list for a single bundle.
+ *
+ * The output combines:
+ * - top-level `dependencies` from the project's `package.json`
+ * - `peerDependencies` (always external regardless of `bundleWorkspaceDeps`)
+ * - the caller-supplied `additional` list
+ *
+ * When `bundleWorkspaceDeps` is `true` and a workspace predicate is supplied, packages
+ * matching the predicate are stripped from `dependencies` and `additional` so they get
+ * inlined by the bundler. Peer dependencies are always preserved.
+ *
+ * @param options - Inputs controlling the resolution.
+ * @returns Sorted, de-duplicated list of external package names.
+ *
+ * @example Resolving externals while inlining workspace deps
+ * ```typescript
+ * const external = resolveExternals({
+ *   packageJsonPath: '/abs/libs/foo/package.json',
+ *   isWorkspacePackage: (n) => n.startsWith('@hyperfrontend/'),
+ *   bundleWorkspaceDeps: true,
+ * })
+ * ```
+ */
+export declare const resolveExternals: (options: ResolveExternalsOptions) => string[];
+//# sourceMappingURL=resolve-externals.d.ts.map

package/bundle/externals/resolve-externals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-externals.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/externals/resolve-externals.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAe,MAAM,cAAc,CAAA;AAM5E;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,qDAAqD;IACrD,eAAe,EAAE,MAAM,CAAA;IACvB,yFAAyF;IACzF,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;IACrB,+FAA+F;IAC/F,kBAAkB,CAAC,EAAE,2BAA2B,CAAA;IAChD,gGAAgG;IAChG,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,EAAE,CAAA;IACtB;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAA;CACpC;AAID;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,gBAAgB,GAAI,SAAS,uBAAuB,KAAG,MAAM,EAsBzE,CAAA"}

package/bundle/externals/validate-globals.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Verifies that every external dependency declared for an IIFE / UMD bundle
+ * has a corresponding entry in the supplied `globals` map.
+ *
+ * Throws an aggregated error listing the missing entries when the configuration
+ * is incomplete; resolves silently otherwise.
+ *
+ * @param external - Package names declared as external for the bundle.
+ * @param globals - Mapping of package name to global variable name.
+ * @throws {Error} When at least one external dependency is missing from `globals`.
+ *
+ * @example Failing fast when a globals mapping is missing
+ * ```typescript
+ * validateExternalsConfig(['react'], { 'react-dom': 'ReactDOM' })
+ * // => throws: Missing globals mapping for external dependencies: react
+ * ```
+ */
+export declare const validateExternalsConfig: (external: string[] | undefined, globals: Record<string, string> | undefined) => void;
+//# sourceMappingURL=validate-globals.d.ts.map

package/bundle/externals/validate-globals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-globals.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/externals/validate-globals.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,uBAAuB,GAAI,UAAU,MAAM,EAAE,GAAG,SAAS,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,KAAG,IAOrH,CAAA"}

package/bundle/fs/deps-root.d.ts

@@ -0,0 +1,17 @@
+import type { BuildContext } from '../../models';
+/**
+ * Resolves the absolute `_dependencies/` root for a build — the bundled-dep
+ * "never touch" zone every prune pass guards. Pair it with {@link isUnderDir} to
+ * derive both the bundled-dep write paths and the guard from one source string.
+ *
+ * @param context - Build context supplying the absolute output root.
+ * @returns Absolute path to `<outputPath>/_dependencies`.
+ *
+ * @example Deriving the write path and the guard from one source
+ * ```typescript
+ * const depsRoot = depsRootOf(context)
+ * if (isUnderDir(candidate, depsRoot)) continue // never touch bundled deps
+ * ```
+ */
+export declare const depsRootOf: (context: BuildContext) => string;
+//# sourceMappingURL=deps-root.d.ts.map

package/bundle/fs/deps-root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deps-root.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/fs/deps-root.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AAGhD;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,UAAU,GAAI,SAAS,YAAY,KAAG,MAAmD,CAAA"}