@hyperfrontend/builder 0.1.0

package/bundle/dependencies/pre-pass.d.ts

@@ -0,0 +1,154 @@
+import type { MemoryMonitor } from '../../memory/monitor';
+import type { WorkspaceBundledDepRoute } from './externalize-plugin';
+/**
+ * Pre-pass kind. Mirrors `PrePassWorkerJobKind` on the worker side.
+ */
+export type PrePassJobKind = 'js' | 'dts' | 'workspace-js' | 'workspace-dts';
+/**
+ * Single-rollup-invocation job description fed to a forked worker.
+ */
+export interface PrePassJob {
+    /**
+     * Pre-pass kind. `js` and `dts` cover npm bundled deps; `workspace-js` and
+     * `workspace-dts` cover workspace `@hyperfrontend/*` deps whose entries are
+     * TypeScript source.
+     */
+    kind: PrePassJobKind;
+    /** Dep package name (or workspace specifier), e.g. `"rollup"` or `"@hyperfrontend/logging"`. */
+    dep: string;
+    /** Absolute path to the dep's input entry. */
+    inputPath: string;
+    /** Format produced by this rollup invocation. */
+    format: 'esm' | 'cjs';
+    /** Absolute path to the worker's output file. */
+    outputPath: string;
+    /** Other deps in the pre-pass set; prefix-matched and marked external so cross-dep imports stay link-time. */
+    otherDeps: string[];
+    /**
+     * Sub-path-mode workspace specifiers in the pre-pass set; matched as exact
+     * specifier only. Used by `workspace-*` jobs so sibling sub-paths externalize
+     * cleanly (e.g., one `built-in-copy/<x>` chunk does not pull in another).
+     */
+    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. See {@link
+     * SiblingEntryDescriptor}. Empty / omitted for dep pre-pass jobs.
+     */
+    siblingEntries?: SiblingEntryDescriptor[];
+    /** Absolute path to the input file's owning entry directory (used to compute sibling specifiers). */
+    selfDtsPath?: string;
+    /** Owning entry's `srcPath`. Empty string for the package root. */
+    selfSrcPath?: string;
+    /**
+     * NPM bundled-dep names consumed by the worker's externalize plugin to rewrite
+     * cross-dep imports to relative paths under {@link depsRoot}. Disjoint from
+     * {@link workspaceRoutes}.
+     */
+    npmDeps?: string[];
+    /**
+     * Workspace bundled-dep routes consumed by the worker's 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;
+}
+/**
+ * Sibling-entry descriptor threaded through to the worker for the per-entry
+ * d.ts pass.
+ */
+export interface SiblingEntryDescriptor {
+    /** Sibling entry's `srcPath` (subpath under `<outputPath>`). `''` for the package root. */
+    srcPath: string;
+    /** Absolute path to the sibling's bundled `index.d.ts`. */
+    indexDtsPath: string;
+}
+/**
+ * Result emitted by the worker for a single job.
+ */
+export interface PrePassResult {
+    /** The job that produced this result. */
+    job: PrePassJob;
+    /** Output file size in bytes. */
+    outputSize: number;
+    /** Heap reported by the child at exit, in MB. */
+    endHeapMB: number;
+    /** RSS reported by the child at exit, in MB. */
+    endRssMB: number;
+    /** Wall-clock duration the worker reported, in ms. */
+    durationMs: number;
+}
+/**
+ * Caller-supplied options threaded through {@link runPrePass}.
+ */
+export interface RunPrePassOptions {
+    /** Absolute path to the worker entry script. Required — see `resolveDefaultWorkerPath`. */
+    workerPath: string;
+    /** Optional memory monitor invoked between every spawned worker. */
+    monitor?: MemoryMonitor;
+    /** Override `process.execPath` for the spawned worker (used by tests). */
+    execPath?: string;
+    /** Extra arguments prepended to the worker invocation (e.g. `['--require', '@swc-node/register']`). */
+    execArgv?: string[];
+}
+/**
+ * Resolved worker invocation: absolute path + any extra Node args (e.g. `--require \@swc-node/register`
+ * when the worker is loaded from TypeScript source during a bootstrap build).
+ */
+export interface WorkerInvocation {
+    /** Absolute path to the worker entry script. */
+    path: string;
+    /** Extra args prepended to the spawned child's argv. */
+    execArgv: string[];
+}
+/**
+ * Default worker-path resolution: prefers the built-and-published artifact, falls
+ * back to the workspace dist path, and finally to the in-source TypeScript file
+ * via `@swc-node/register` (bootstrap case where builder is building itself for
+ * the first time and the dist worker doesn't exist yet).
+ *
+ * Looks at, in order:
+ * 1. `<workspaceRoot>/dist/libs/builder/bundle/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')
+ * ```
+ */
+export declare const resolveDefaultWorkerPath: (workspaceRoot: string) => WorkerInvocation | 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' })
+ * ```
+ */
+export declare const runPrePass: (jobs: PrePassJob[], options: RunPrePassOptions) => Promise<PrePassResult[]>;
+//# sourceMappingURL=pre-pass.d.ts.map

package/bundle/dependencies/pre-pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pre-pass.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/dependencies/pre-pass.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACzD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAA;AAYpE;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,IAAI,GAAG,KAAK,GAAG,cAAc,GAAG,eAAe,CAAA;AAE5E;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB;;;;OAIG;IACH,IAAI,EAAE,cAAc,CAAA;IACpB,gGAAgG;IAChG,GAAG,EAAE,MAAM,CAAA;IACX,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAA;IACjB,iDAAiD;IACjD,MAAM,EAAE,KAAK,GAAG,KAAK,CAAA;IACrB,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAA;IAClB,8GAA8G;IAC9G,SAAS,EAAE,MAAM,EAAE,CAAA;IACnB;;;;OAIG;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,sBAAsB,EAAE,CAAA;IACzC,qGAAqG;IACrG,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,mEAAmE;IACnE,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB;;;;OAIG;IACH,eAAe,CAAC,EAAE,wBAAwB,EAAE,CAAA;IAC5C,mIAAmI;IACnI,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAsB;IACrC,2FAA2F;IAC3F,OAAO,EAAE,MAAM,CAAA;IACf,2DAA2D;IAC3D,YAAY,EAAE,MAAM,CAAA;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,yCAAyC;IACzC,GAAG,EAAE,UAAU,CAAA;IACf,iCAAiC;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,iDAAiD;IACjD,SAAS,EAAE,MAAM,CAAA;IACjB,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAA;IAChB,sDAAsD;IACtD,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,2FAA2F;IAC3F,UAAU,EAAE,MAAM,CAAA;IAClB,oEAAoE;IACpE,OAAO,CAAC,EAAE,aAAa,CAAA;IACvB,0EAA0E;IAC1E,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,uGAAuG;IACvG,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;CACpB;AA8DD;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAA;IACZ,wDAAwD;IACxD,QAAQ,EAAE,MAAM,EAAE,CAAA;CACnB;AAOD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,wBAAwB,GAAI,eAAe,MAAM,KAAG,gBAAgB,GAAG,SAanF,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,UAAU,GAAU,MAAM,UAAU,EAAE,EAAE,SAAS,iBAAiB,KAAG,OAAO,CAAC,aAAa,EAAE,CAqBxG,CAAA"}

package/bundle/dependencies/prune/ast-utils.d.ts

@@ -0,0 +1,121 @@
+import ts from 'typescript';
+/**
+ * Parses a bundled chunk's source into a `ts.SourceFile`.
+ *
+ * Always parses as plain JavaScript with parent pointers set, so callers can
+ * inspect each node's lexical context (member-access position, declaration
+ * names) during the dead-export analysis.
+ *
+ * @param source - Raw chunk source text.
+ * @returns The parsed source file with parent nodes populated.
+ *
+ * @example Parsing a chunk before analysis
+ * ```typescript
+ * const sourceFile = parseChunk("export { a };\nconst a = 1")
+ * ```
+ */
+export declare const parseChunk: (source: string) => ts.SourceFile;
+/**
+ * Resolves a module specifier to the absolute chunk path it targets, or `null`
+ * when the specifier is not a relative chunk reference.
+ *
+ * Only specifiers starting with `.` are real edges into the `_dependencies/`
+ * tree; bare and node-builtin specifiers resolve to `null` and are ignored by
+ * reachability and usage analysis alike.
+ *
+ * @param importerDir - Absolute directory of the file containing the specifier.
+ * @param specifier - The raw module specifier string.
+ * @returns The absolute resolved path, or `null` for non-relative specifiers.
+ *
+ * @example Resolving a sibling chunk reference
+ * ```typescript
+ * resolveRelativeTarget('/dist/libs/foo/_dependencies/a', '../b/index.esm.js')
+ * // => '/dist/libs/foo/_dependencies/b/index.esm.js'
+ * ```
+ */
+export declare const resolveRelativeTarget: (importerDir: string, specifier: string) => string | null;
+/**
+ * Returns the literal specifier of a `require('…')` call expression, or `null`
+ * when the node is not a single-string-literal `require` call.
+ *
+ * @param node - Any AST node.
+ * @returns The required specifier string, or `null`.
+ *
+ * @example Extracting a CJS chunk dependency
+ * ```typescript
+ * // for the call node in `var x = require('./dep/index.cjs.js')`
+ * getRequireSpecifier(callNode) // => './dep/index.cjs.js'
+ * ```
+ */
+export declare const getRequireSpecifier: (node: ts.Node) => string | null;
+/** `require('F').Export` — a single export selected by static property access. */
+export interface RequirePropShape {
+    /** Discriminant. */
+    kind: 'prop';
+    /** The member node, for classifying how the selected export is then used. */
+    member: ts.PropertyAccessExpression;
+    /** The selected export name. */
+    name: string;
+}
+/** `require('F')['Export']` — a single export selected by string-literal element access. */
+export interface RequireElemStaticShape {
+    /** Discriminant. */
+    kind: 'elem-static';
+    /** The member node, for classifying how the selected export is then used. */
+    member: ts.ElementAccessExpression;
+    /** The selected export name. */
+    name: string;
+}
+/** `require('F')[k]` — a computed element access that could select any export. */
+export interface RequireElemDynamicShape {
+    /** Discriminant. */
+    kind: 'elem-dynamic';
+}
+/** A bare `require('F');` expression statement that binds nothing — side-effect only. */
+export interface RequireSideEffectShape {
+    /** Discriminant. */
+    kind: 'side-effect';
+}
+/** `var dep = require('F')` — the whole module bound to a local identifier. */
+export interface RequireNsBindingShape {
+    /** Discriminant. */
+    kind: 'ns-binding';
+    /** The bound local identifier. */
+    name: ts.Identifier;
+}
+/** `var { … } = require('F')` — the module destructured into named locals. */
+export interface RequireDestructureShape {
+    /** Discriminant. */
+    kind: 'destructure';
+    /** The binding pattern destructured from the require result. */
+    pattern: ts.ObjectBindingPattern;
+}
+/** Any other position (call argument, spread, reassignment, …) — consumes the module wholesale. */
+export interface RequireEscapeShape {
+    /** Discriminant. */
+    kind: 'escape';
+}
+/**
+ * The syntactic shape of how a `require('…')` call's result is consumed,
+ * derived from the call's parent node.
+ */
+export type RequireBindingShape = RequirePropShape | RequireElemStaticShape | RequireElemDynamicShape | RequireSideEffectShape | RequireNsBindingShape | RequireDestructureShape | RequireEscapeShape;
+/**
+ * Classifies how a `require('…')` call's result is consumed, by inspecting the
+ * call's parent node.
+ *
+ * A bare `require('F');` statement is classified as `side-effect`, not `escape`.
+ * A `require('F').#priv` (not valid JS) does not match `prop` and falls through
+ * to `escape`.
+ *
+ * @param call - The `require('…')` call expression to classify.
+ * @returns The discriminated shape of the call's binding position.
+ *
+ * @example A destructured require
+ * ```typescript
+ * // for the call in `var { a, b } = require('./x.cjs.js')`
+ * classifyRequireBinding(call) // => { kind: 'destructure', pattern: … }
+ * ```
+ */
+export declare const classifyRequireBinding: (call: ts.CallExpression) => RequireBindingShape;
+//# sourceMappingURL=ast-utils.d.ts.map

package/bundle/dependencies/prune/ast-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-utils.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/prune/ast-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAA;AAG3B;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,MAAM,KAAG,EAAE,CAAC,UAC0C,CAAA;AAEzF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB,GAAI,aAAa,MAAM,EAAE,WAAW,MAAM,KAAG,MAAM,GAAG,IACvB,CAAA;AAEjE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,EAAE,CAAC,IAAI,KAAG,MAAM,GAAG,IAK5D,CAAA;AAED,kFAAkF;AAClF,MAAM,WAAW,gBAAgB;IAC/B,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,6EAA6E;IAC7E,MAAM,EAAE,EAAE,CAAC,wBAAwB,CAAA;IACnC,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAA;CACb;AAED,4FAA4F;AAC5F,MAAM,WAAW,sBAAsB;IACrC,oBAAoB;IACpB,IAAI,EAAE,aAAa,CAAA;IACnB,6EAA6E;IAC7E,MAAM,EAAE,EAAE,CAAC,uBAAuB,CAAA;IAClC,gCAAgC;IAChC,IAAI,EAAE,MAAM,CAAA;CACb;AAED,kFAAkF;AAClF,MAAM,WAAW,uBAAuB;IACtC,oBAAoB;IACpB,IAAI,EAAE,cAAc,CAAA;CACrB;AAED,yFAAyF;AACzF,MAAM,WAAW,sBAAsB;IACrC,oBAAoB;IACpB,IAAI,EAAE,aAAa,CAAA;CACpB;AAED,+EAA+E;AAC/E,MAAM,WAAW,qBAAqB;IACpC,oBAAoB;IACpB,IAAI,EAAE,YAAY,CAAA;IAClB,kCAAkC;IAClC,IAAI,EAAE,EAAE,CAAC,UAAU,CAAA;CACpB;AAED,8EAA8E;AAC9E,MAAM,WAAW,uBAAuB;IACtC,oBAAoB;IACpB,IAAI,EAAE,aAAa,CAAA;IACnB,gEAAgE;IAChE,OAAO,EAAE,EAAE,CAAC,oBAAoB,CAAA;CACjC;AAED,mGAAmG;AACnG,MAAM,WAAW,kBAAkB;IACjC,oBAAoB;IACpB,IAAI,EAAE,QAAQ,CAAA;CACf;AAED;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAC3B,gBAAgB,GAChB,sBAAsB,GACtB,uBAAuB,GACvB,sBAAsB,GACtB,qBAAqB,GACrB,uBAAuB,GACvB,kBAAkB,CAAA;AAEtB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,sBAAsB,GAAI,MAAM,EAAE,CAAC,cAAc,KAAG,mBAahE,CAAA"}

package/bundle/dependencies/prune/chunk-graph.d.ts

@@ -0,0 +1,175 @@
+import type { ChunkFormat } from './used-exports';
+import ts from 'typescript';
+/**
+ * A removable-candidate top-level declaration: a `function`/`class`/`var`
+ * statement and the names it binds, tagged with whether evaluating it is free
+ * of observable side effects.
+ */
+export interface DeclInfo {
+    /** The owning top-level statement. */
+    statement: ts.Statement;
+    /** Every name the statement binds (one for func/class, ≥1 for `var`). */
+    names: string[];
+    /** True when the statement may be deleted without dropping a side effect. */
+    sideEffectFree: boolean;
+}
+/**
+ * One entry in a chunk's public export surface, linking an exported name to the
+ * local declaration that backs it and the statement that declares the export.
+ */
+export interface ExportEntry {
+    /** The name visible to importers. */
+    exported: string;
+    /** The local declaration name the export resolves to. */
+    local: string;
+    /** The statement that publishes the export. */
+    statement: ts.Statement;
+    /** Shape of the export site, governing how it is edited when pruned. */
+    kind: 'esm-list' | 'esm-inline' | 'cjs-assign';
+}
+/**
+ * Structural model of a single bundled chunk used to drive dead-export removal.
+ */
+export interface ChunkModel {
+    /** Map from each declared name to its declaration. */
+    nameToDecl: Map<string, DeclInfo>;
+    /** Unique declarations in source order. */
+    decls: DeclInfo[];
+    /** Statements that are import sites (ESM `import` or CJS `require` bindings). */
+    importStatements: ts.Statement[];
+    /** The chunk's export surface. */
+    exports: ExportEntry[];
+    /** Statements that publish exports via a separate `export { … }` / `exports.x =` site. */
+    exportSurfaceStatements: Set<ts.Statement>;
+}
+/**
+ * Resolution of a chunk's top-level bindings, used to recognize a pure callee
+ * regardless of how the global was aliased.
+ */
+export interface BindingResolution {
+    /** Every name bound at top level (const/var/function/class) — used to detect a global shadowed by a local. */
+    bindings: Set<string>;
+    /** Bindings whose initializer is an identifier/property chain rooted in a global, mapped to that global-rooted dotted form. */
+    canonical: Map<string, string>;
+}
+/**
+ * Maps each top-level binding to its canonical global-rooted callee form, in
+ * source order so a later alias resolves through an earlier one. Both `const`
+ * and `var` are resolved; bundled dep chunks never reassign these interop
+ * bindings. A call/literal initializer is opaque and only contributes a
+ * shadowing entry in `bindings`.
+ *
+ * @param sourceFile - The parsed chunk whose top-level bindings are resolved.
+ * @returns The binding resolution: every top-level name plus the global-rooted
+ * canonical form of each identifier/property-chain alias.
+ *
+ * @example Resolving an alias-of-global freeze
+ * ```typescript
+ * const { canonical } = collectBindingCanonical(parseChunk('const _O = globalThis.Object;\nconst freeze = _O.freeze;'))
+ * canonical.get('freeze') // => 'Object.freeze'
+ * ```
+ */
+export declare const collectBindingCanonical: (sourceFile: ts.SourceFile) => BindingResolution;
+/**
+ * Reports whether a call is a recognized pure callee
+ * (`Object.freeze`/`seal`/`preventExtensions`, however aliased) over a fresh
+ * object/array literal. The argument must be a same-expression literal —
+ * freezing a shared binding mutates it observably, so an identifier argument is
+ * rejected. This checks only the callee and argument shape, not the purity of
+ * the argument's own subexpressions.
+ *
+ * @param call - The call expression to classify.
+ * @param resolution - The chunk's binding resolution, used to canonicalize the callee.
+ * @returns `true` when the call is an observably pure freeze of a fresh literal.
+ *
+ * @example Recognizing an aliased freeze of a fresh literal
+ * ```typescript
+ * const sourceFile = parseChunk('const _O = globalThis.Object;\nconst X = _O.freeze({ a: 1 });')
+ * // for the `_O.freeze({ a: 1 })` call node
+ * isPureFreezeCall(call, collectBindingCanonical(sourceFile)) // => true
+ * ```
+ */
+export declare const isPureFreezeCall: (call: ts.CallExpression, resolution: BindingResolution) => boolean;
+/**
+ * Reports whether a call is `<global-rooted chain>.bind(…)`.
+ * `Function.prototype.bind` only builds and returns a new bound function — no
+ * observable side effect. The receiver must canonicalize to a global so an
+ * arbitrary user object's `.bind` — potentially a redefined, side-effecting
+ * method — is never assumed pure. As with {@link isPureFreezeCall}, this checks
+ * only the call shape, not the purity of the argument's own subexpressions.
+ *
+ * @param call - The call expression to classify.
+ * @param resolution - The chunk's binding resolution, used to canonicalize the receiver.
+ * @returns `true` when the call binds a method off a global-rooted receiver chain.
+ *
+ * @example Recognizing a bind of a global-rooted receiver
+ * ```typescript
+ * const sourceFile = parseChunk('const _P = globalThis.Promise;\nconst X = _P.resolve.bind(_P);')
+ * // for the `_P.resolve.bind(_P)` call node
+ * isPureBindCall(call, collectBindingCanonical(sourceFile)) // => true
+ * ```
+ */
+export declare const isPureBindCall: (call: ts.CallExpression, resolution: BindingResolution) => boolean;
+/**
+ * Collects the identifier names referenced within a node, excluding identifiers
+ * that sit in a property-name position (`obj.name`, `{ name: … }`, `{ name: x }`
+ * binding keys) since those never refer to a top-level declaration.
+ *
+ * Deliberately over-approximates: a name captured that is not actually a
+ * top-level declaration is harmless, and capturing more only keeps more code.
+ *
+ * @param node - The subtree to scan.
+ * @param sink - Set that receives every referenced identifier name.
+ *
+ * @example Collecting references inside a function body
+ * ```typescript
+ * const refs = createSet<string>([])
+ * collectRefs(functionDeclaration, refs)
+ * ```
+ */
+export declare const collectRefs: (node: ts.Node, sink: Set<string>) => void;
+/**
+ * Returns the local binding names introduced by a CJS `require` variable
+ * statement, across identifier and object-destructure bindings.
+ *
+ * @param statement - A variable statement known to bind a `require` call.
+ * @returns The local names it introduces.
+ *
+ * @example Bindings of a destructured require
+ * ```typescript
+ * // for `var { a, b } = require('./x.cjs.js')`
+ * requireBindingLocals(statement) // => ['a', 'b']
+ * ```
+ */
+export declare const requireBindingLocals: (statement: ts.Statement) => string[];
+/**
+ * Builds the structural model of a chunk: its removable declarations, import
+ * sites, and export surface.
+ *
+ * @param sourceFile - The parsed chunk.
+ * @param format - Module format selecting ESM vs CJS export/import shapes.
+ * @returns The chunk model consumed by {@link computeKeepClosure}.
+ *
+ * @example Modeling an ESM chunk
+ * ```typescript
+ * const model = analyzeChunk(parseChunk(source), 'esm')
+ * ```
+ */
+export declare const analyzeChunk: (sourceFile: ts.SourceFile, format: ChunkFormat) => ChunkModel;
+/**
+ * Computes the closure of local declaration names that must be retained: every
+ * kept export, every side-effecting declaration, every name referenced by a
+ * bare top-level statement, and everything those transitively reference.
+ *
+ * @param sourceFile - The parsed chunk.
+ * @param model - The chunk model from {@link analyzeChunk}.
+ * @param keep - Exported names demanded by importers.
+ * @returns The set of local names that may not be removed.
+ *
+ * @example Names that survive given a one-export demand
+ * ```typescript
+ * const live = computeKeepClosure(sourceFile, model, createSet(['getType']))
+ * ```
+ */
+export declare const computeKeepClosure: (sourceFile: ts.SourceFile, model: ChunkModel, keep: Set<string>) => Set<string>;
+//# sourceMappingURL=chunk-graph.d.ts.map

package/bundle/dependencies/prune/chunk-graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk-graph.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/prune/chunk-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AACjD,OAAO,EAAE,MAAM,YAAY,CAAA;AAM3B;;;;GAIG;AACH,MAAM,WAAW,QAAQ;IACvB,sCAAsC;IACtC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAA;IACvB,yEAAyE;IACzE,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,6EAA6E;IAC7E,cAAc,EAAE,OAAO,CAAA;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,qCAAqC;IACrC,QAAQ,EAAE,MAAM,CAAA;IAChB,yDAAyD;IACzD,KAAK,EAAE,MAAM,CAAA;IACb,+CAA+C;IAC/C,SAAS,EAAE,EAAE,CAAC,SAAS,CAAA;IACvB,wEAAwE;IACxE,IAAI,EAAE,UAAU,GAAG,YAAY,GAAG,YAAY,CAAA;CAC/C;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,sDAAsD;IACtD,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IACjC,2CAA2C;IAC3C,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,iFAAiF;IACjF,gBAAgB,EAAE,EAAE,CAAC,SAAS,EAAE,CAAA;IAChC,kCAAkC;IAClC,OAAO,EAAE,WAAW,EAAE,CAAA;IACtB,0FAA0F;IAC1F,uBAAuB,EAAE,GAAG,CAAC,EAAE,CAAC,SAAS,CAAC,CAAA;CAC3C;AAiBD;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,8GAA8G;IAC9G,QAAQ,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACrB,+HAA+H;IAC/H,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC/B;AAmBD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,uBAAuB,GAAI,YAAY,EAAE,CAAC,UAAU,KAAG,iBAiBnE,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,EAAE,CAAC,cAAc,EAAE,YAAY,iBAAiB,KAAG,OAMzF,CAAA;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,GAAI,MAAM,EAAE,CAAC,cAAc,EAAE,YAAY,iBAAiB,KAAG,OAIvF,CAAA;AAsCD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,WAAW,GAAI,MAAM,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC,MAAM,CAAC,KAAG,IAa9D,CAAA;AAYD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,GAAI,WAAW,EAAE,CAAC,SAAS,KAAG,MAAM,EASpE,CAAA;AAuDD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,YAAY,GAAI,YAAY,EAAE,CAAC,UAAU,EAAE,QAAQ,WAAW,KAAG,UAsB7E,CAAA;AAcD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,kBAAkB,GAAI,YAAY,EAAE,CAAC,UAAU,EAAE,OAAO,UAAU,EAAE,MAAM,GAAG,CAAC,MAAM,CAAC,KAAG,GAAG,CAAC,MAAM,CAsB9G,CAAA"}

package/bundle/dependencies/prune/dead-export-pass.d.ts

@@ -0,0 +1,32 @@
+import type { BuildContext } from '../../../models';
+/**
+ * Aggregate result of the dead-export stripping pass.
+ */
+export interface DeadExportPassResult {
+    /** Exported declarations spliced out across all chunks and iterations. */
+    deadExportsRemoved: number;
+    /** Bytes reclaimed by shrinking chunk sources. */
+    bytesRemoved: number;
+}
+/**
+ * Shrinks surviving `_dependencies/` chunks by stripping dead exported
+ * declarations, iterating to a fixpoint per format.
+ *
+ * Each iteration re-derives the importer demand for every surviving chunk from
+ * the current on-disk sources (entries plus sibling chunks), strips each chunk
+ * to that demand, and repeats until no chunk changes — because removing one
+ * chunk's import can make another chunk's export dead in turn. ESM and CJS are
+ * processed independently. The orphan sweep is expected to run afterwards to
+ * reclaim any chunk whose last import was removed here.
+ *
+ * @param context - Resolved build context supplying the entry points.
+ * @param depsRoot - Absolute path to the `_dependencies/` directory.
+ * @returns Counts of exports removed and bytes reclaimed.
+ *
+ * @example Running the strip pass after the orphan sweep
+ * ```typescript
+ * const { deadExportsRemoved } = stripDeadExportsPass(context, depsRootOf(context))
+ * ```
+ */
+export declare const stripDeadExportsPass: (context: BuildContext, depsRoot: string) => DeadExportPassResult;
+//# sourceMappingURL=dead-export-pass.d.ts.map

package/bundle/dependencies/prune/dead-export-pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dead-export-pass.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/prune/dead-export-pass.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AA+BnD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,0EAA0E;IAC1E,kBAAkB,EAAE,MAAM,CAAA;IAC1B,kDAAkD;IAClD,YAAY,EAAE,MAAM,CAAA;CACrB;AA0DD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,oBAAoB,GAAI,SAAS,YAAY,EAAE,UAAU,MAAM,KAAG,oBAK9E,CAAA"}

package/bundle/dependencies/prune/dead-exports.d.ts

@@ -0,0 +1,36 @@
+import type { ChunkFormat, ImportUsage } from './used-exports';
+/**
+ * Outcome of stripping a single chunk.
+ */
+export interface StripResult {
+    /** Rewritten chunk source with dead declarations and exports removed. */
+    code: string;
+    /** Exported names that were spliced out. */
+    removedNames: string[];
+}
+/**
+ * Removes guaranteed-dead exported declarations (and the now-dead private code
+ * and imports they pulled in) from a single chunk's source.
+ *
+ * Builds the chunk's declaration/export model, computes the keep-closure from
+ * the importer-supplied `keep` demand, and splices out every side-effect-free
+ * top-level declaration that no kept declaration, kept export, or bare
+ * side-effecting statement references. The matching entries are dropped from the
+ * export surface, and import bindings left unreferenced by the surviving code are
+ * narrowed away (whole import statements when fully unused) — which is what
+ * shrinks the cross-chunk dependency graph for the next fixpoint pass.
+ * Side-effecting initializers and bare statements are always kept.
+ *
+ * @param source - Raw chunk source text.
+ * @param format - Module format of the chunk.
+ * @param keep - Exported names importers demand, or `'all'` to keep everything.
+ * @returns The rewritten source and removed export names, or `null` when nothing
+ * could be removed.
+ *
+ * @example Stripping all but one export from a chunk
+ * ```typescript
+ * stripDeadExports(source, 'esm', createSet(['getType']))
+ * ```
+ */
+export declare const stripDeadExports: (source: string, format: ChunkFormat, keep: ImportUsage) => StripResult | null;
+//# sourceMappingURL=dead-exports.d.ts.map

package/bundle/dependencies/prune/dead-exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dead-exports.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/prune/dead-exports.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AAS9D;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,yEAAyE;IACzE,IAAI,EAAE,MAAM,CAAA;IACZ,4CAA4C;IAC5C,YAAY,EAAE,MAAM,EAAE,CAAA;CACvB;AAoDD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,gBAAgB,GAAI,QAAQ,MAAM,EAAE,QAAQ,WAAW,EAAE,MAAM,WAAW,KAAG,WAAW,GAAG,IA2BvG,CAAA"}

package/bundle/dependencies/prune/destructure-requires-pass.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Aggregate result of the require-destructuring pass.
+ */
+export interface DestructureRequiresResult {
+    /** Whole-module `const NS = require(...)` bindings collapsed to destructures. */
+    requireBindingsDestructured: number;
+}
+/**
+ * Collapses whole-module CJS require bindings (`const NS = require('./rel')`) to
+ * destructuring binds across the surviving `_dependencies/` chunks, guarded so it
+ * never destructures across a `require` cycle.
+ *
+ * Builds the relative-require graph over the CJS chunks, finds its
+ * strongly-connected components, and lets each chunk destructure a target only
+ * when the two sit in different components — i.e. the edge is acyclic, so an
+ * eager destructure cannot capture an export before a circular dependency
+ * finished initializing (the exact hazard rollup's namespace-access codegen
+ * avoids). ESM chunks need nothing: their named imports already destructure. A
+ * dynamic `import(`/`require(` anywhere disables the pass for safety, since it
+ * could hide a cycle the static graph cannot see.
+ *
+ * @param depsRoot - Absolute path to the `_dependencies/` directory.
+ * @returns Count of require bindings destructured.
+ *
+ * @example Running the pass after the strip/orphan passes
+ * ```typescript
+ * const { requireBindingsDestructured } = destructureRequiresPass(depsRootOf(context))
+ * ```
+ */
+export declare const destructureRequiresPass: (depsRoot: string) => DestructureRequiresResult;
+//# sourceMappingURL=destructure-requires-pass.d.ts.map

package/bundle/dependencies/prune/destructure-requires-pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"destructure-requires-pass.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/prune/destructure-requires-pass.ts"],"names":[],"mappings":"AAyBA;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,iFAAiF;IACjF,2BAA2B,EAAE,MAAM,CAAA;CACpC;AAsFD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,uBAAuB,GAAI,UAAU,MAAM,KAAG,yBA8B1D,CAAA"}

package/bundle/dependencies/prune/destructure-requires.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Outcome of destructuring a single CJS chunk's whole-module require bindings.
+ */
+export interface DestructureResult {
+    /** Rewritten chunk source. */
+    code: string;
+    /** Number of `const NS = require(...)` bindings collapsed to destructures. */
+    rewrittenBindings: number;
+}
+/**
+ * Rewrites whole-module CJS require bindings to destructuring binds when the
+ * binding is consumed only as static member reads.
+ *
+ * For every top-level `const NS = require('./rel')` whose target `isSafeTarget`
+ * accepts (a relative sibling chunk that is provably not in a `require` cycle
+ * with this chunk), and where `NS` is used exclusively as `NS.member` /
+ * `NS['member']` reads, the binding is collapsed to `const { member, … } =
+ * require('./rel')` and each `NS.member` access is replaced by the bound local.
+ * Locals that would collide with an existing free identifier or another bound
+ * local are aliased (`member: member$1`) — so the rewrite never shadows the
+ * chunk's own names. Any wholesale, dynamic, or reassigning use of `NS` leaves
+ * its binding untouched, matching rollup's namespace-access codegen.
+ *
+ * The cycle guard is the caller's responsibility: rollup keeps the namespace
+ * form precisely so an eager destructure cannot capture an export before a
+ * circular dependency has initialized it. Passing only acyclic targets to
+ * `isSafeTarget` preserves that guarantee.
+ *
+ * @param source - Raw CJS chunk source text.
+ * @param chunkDir - Absolute directory of the chunk, for resolving relative requires.
+ * @param isSafeTarget - Predicate selecting which resolved require targets may be destructured.
+ * @returns The rewritten source and the count of bindings destructured, or `null`
+ * when no binding qualified.
+ *
+ * @example Destructuring a single-member require
+ * ```typescript
+ * destructureRequires("const m = require('./math/index.cjs.js');\nm.abs(x);", '/d/p', () => true)
+ * // => { code: "const { abs } = require('./math/index.cjs.js');\nabs(x);", rewrittenBindings: 1 }
+ * ```
+ */
+export declare const destructureRequires: (source: string, chunkDir: string, isSafeTarget: (target: string) => boolean) => DestructureResult | null;
+//# sourceMappingURL=destructure-requires.d.ts.map

package/bundle/dependencies/prune/destructure-requires.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"destructure-requires.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/prune/destructure-requires.ts"],"names":[],"mappings":"AAQA;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,8EAA8E;IAC9E,iBAAiB,EAAE,MAAM,CAAA;CAC1B;AA+GD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,mBAAmB,GAC9B,QAAQ,MAAM,EACd,UAAU,MAAM,EAChB,cAAc,CAAC,MAAM,EAAE,MAAM,KAAK,OAAO,KACxC,iBAAiB,GAAG,IA8BtB,CAAA"}

package/bundle/dependencies/prune/edits.d.ts

@@ -0,0 +1,30 @@
+/** A single text replacement over the original chunk source. */
+export interface Edit {
+    /** Inclusive start offset. */
+    start: number;
+    /** Exclusive end offset. */
+    end: number;
+    /** Replacement text (empty string deletes the span). */
+    text: string;
+}
+/**
+ * Applies text-range edits to a chunk source by splicing each span in
+ * descending start order, so every edit's offsets stay valid against the
+ * original source regardless of the order they are passed in. All offsets must
+ * refer to the original `source`, and spans must not overlap. The input `edits`
+ * array is copied before sorting, so the caller's order is left untouched.
+ *
+ * @param source - Original chunk source text.
+ * @param edits - Edits to apply; their relative order does not matter.
+ * @param collapseBlankLines - When `true`, runs of three or more newlines left
+ * behind by whole-statement splices are collapsed to a single blank line so the
+ * trimmed chunk stays readable. Defaults to `false`.
+ * @returns The rewritten source.
+ *
+ * @example Deleting a statement and collapsing the blank run it leaves
+ * ```typescript
+ * applyEdits(source, [{ start, end, text: '' }], true)
+ * ```
+ */
+export declare const applyEdits: (source: string, edits: Edit[], collapseBlankLines?: boolean) => string;
+//# sourceMappingURL=edits.d.ts.map