@hyperfrontend/builder 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"edits.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/prune/edits.ts"],"names":[],"mappings":"AAAA,gEAAgE;AAChE,MAAM,WAAW,IAAI;IACnB,8BAA8B;IAC9B,KAAK,EAAE,MAAM,CAAA;IACb,4BAA4B;IAC5B,GAAG,EAAE,MAAM,CAAA;IACX,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAA;CACb;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,UAAU,GAAI,QAAQ,MAAM,EAAE,OAAO,IAAI,EAAE,EAAE,4BAA0B,KAAG,MAKtF,CAAA"}

package/bundle/dependencies/prune/namespace-usage.d.ts

@@ -0,0 +1,104 @@
+import type { ChunkFormat } from './used-exports';
+import ts from 'typescript';
+/**
+ * Property-level demand on a single namespace export: either the concrete set of
+ * property names statically read off it, or `'all'` — the safety sentinel
+ * meaning the binding is consumed in a way that forbids dropping any slot
+ * (spread, passed/returned/assigned wholesale, enumerated, dynamically indexed,
+ * or re-exported).
+ */
+export type PropDemand = Set<string> | 'all';
+/**
+ * How one importer (or the defining chunk itself) consumes the namespace exports
+ * of a single target chunk.
+ */
+export interface NamespaceTargetUsage {
+    /** True when the target is imported wholesale (namespace/default import, `export *`), so no export of it is strippable. */
+    bailAll: boolean;
+    /** Per-export-name property demand for the target's named imports. */
+    perName: Map<string, PropDemand>;
+}
+/**
+ * Merges a property demand into a per-export demand map, with `'all'` absorbing.
+ *
+ * @param demand - Map from export name to its accumulated property demand.
+ * @param name - The export name receiving the contribution.
+ * @param contribution - Either a set of read property names or `'all'`.
+ *
+ * @example Accumulating two reads of the same export
+ * ```typescript
+ * mergeDemand(demand, 'SafeObject', createSet(['freeze']))
+ * mergeDemand(demand, 'SafeObject', createSet(['keys'])) // => { SafeObject: { freeze, keys } }
+ * ```
+ */
+export declare const mergeDemand: (demand: Map<string, PropDemand>, name: string, contribution: PropDemand) => void;
+/** A static read of one property off the namespace binding. */
+export interface NamespaceReadUse {
+    /** Discriminant. */
+    kind: 'read';
+    /** The property name read. */
+    prop: string;
+}
+/** A wholesale consumption that forbids dropping any slot. */
+export interface NamespaceBailUse {
+    /** Discriminant. */
+    kind: 'bail';
+}
+/** An occurrence that does not reference the binding's value. */
+export interface NamespaceIgnoreUse {
+    /** Discriminant. */
+    kind: 'ignore';
+}
+/**
+ * Outcome of classifying one syntactic occurrence of a namespace binding.
+ */
+export type UseClassification = NamespaceReadUse | NamespaceBailUse | NamespaceIgnoreUse;
+/**
+ * Classifies a single identifier occurrence of a namespace binding as a static
+ * property read, a wholesale-escape that forbids stripping, or an unrelated
+ * position that names something else.
+ *
+ * Only `NS.prop` and `NS["prop"]` are property reads; a dynamic `NS[k]`, a
+ * spread, or any value position (call argument, assignment, return, re-export,
+ * shorthand) is an escape. A value sitting as a member name (`obj.NS`),
+ * object-literal key (`{ NS: … }`), or binding property name is unrelated. The
+ * value is usually an identifier binding, but may be a member node (`dep.NS`)
+ * when classifying the use of a CJS export selected off a require binding.
+ *
+ * @param node - The expression occurrence to classify (an identifier binding or a `dep.Export` member node).
+ * @returns The classification of this occurrence.
+ *
+ * @example A static property read
+ * ```typescript
+ * // for the `NS` in `NS.freeze(x)`
+ * classifyNamespaceUse(id) // => { kind: 'read', prop: 'freeze' }
+ * ```
+ */
+export declare const classifyNamespaceUse: (node: ts.Expression) => UseClassification;
+/**
+ * Builds the per-target namespace-usage map an ESM importer declares: for every
+ * relative chunk it imports, which exported names it reads at a strict set of
+ * properties versus consumes wholesale.
+ *
+ * ESM named imports (`import { NS as L }`) and CJS destructured requires
+ * (`const { NS: L } = require('F')`) bind an export to a local `L` tracked
+ * one-level: every occurrence of `L` is classified. A CJS whole-module binding
+ * (`const dep = require('F')`) is tracked two-level: `dep.NS.prop` reads the
+ * property `prop` of export `NS`. A namespace/default import, `export *`, a
+ * dynamic `dep[k]`, or any wholesale use of the module binding marks the target
+ * `bailAll`; a re-export marks the re-exported name `'all'`. The importer is
+ * parsed exactly once and released by the caller.
+ *
+ * @param source - Raw importer source text.
+ * @param importerDir - Absolute directory of the importer file.
+ * @param format - Module format selecting ESM `import` vs CJS `require` edges.
+ * @returns Map from resolved chunk path to its namespace usage.
+ *
+ * @example Reading two slots off an imported namespace
+ * ```typescript
+ * collectNamespaceUsage("import { SafeObject } from './d/index.esm.js';\nSafeObject.freeze(x);\nSafeObject.keys(y);", '/dist/libs/foo', 'esm')
+ * // => Map { '/dist/libs/foo/d/index.esm.js' => { bailAll: false, perName: { SafeObject: { freeze, keys } } } }
+ * ```
+ */
+export declare const collectNamespaceUsage: (source: string, importerDir: string, format: ChunkFormat) => Map<string, NamespaceTargetUsage>;
+//# sourceMappingURL=namespace-usage.d.ts.map

package/bundle/dependencies/prune/namespace-usage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"namespace-usage.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/prune/namespace-usage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AACjD,OAAO,EAAE,MAAM,YAAY,CAAA;AAK3B;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,KAAK,CAAA;AAE5C;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,2HAA2H;IAC3H,OAAO,EAAE,OAAO,CAAA;IAChB,sEAAsE;IACtE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;CACjC;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,WAAW,GAAI,QAAQ,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,MAAM,EAAE,cAAc,UAAU,KAAG,IASrG,CAAA;AAED,+DAA+D;AAC/D,MAAM,WAAW,gBAAgB;IAC/B,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,8BAA8B;IAC9B,IAAI,EAAE,MAAM,CAAA;CACb;AAED,8DAA8D;AAC9D,MAAM,WAAW,gBAAgB;IAC/B,oBAAoB;IACpB,IAAI,EAAE,MAAM,CAAA;CACb;AAED,iEAAiE;AACjE,MAAM,WAAW,kBAAkB;IACjC,oBAAoB;IACpB,IAAI,EAAE,QAAQ,CAAA;CACf;AAED;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,GAAG,gBAAgB,GAAG,kBAAkB,CAAA;AAExF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,oBAAoB,GAAI,MAAM,EAAE,CAAC,UAAU,KAAG,iBAe1D,CAAA;AAgLD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,MAAM,EAAE,aAAa,MAAM,EAAE,QAAQ,WAAW,KAAG,GAAG,CAAC,MAAM,EAAE,oBAAoB,CAkBhI,CAAA"}

package/bundle/dependencies/prune/orphan-chunks.d.ts

@@ -0,0 +1,69 @@
+import type { BuildContext } from '../../../models';
+/**
+ * Outcome of the Orphan Sweep.
+ */
+export interface OrphanPruneResult {
+    /** Number of files unlinked (chunks plus their `.map` siblings). */
+    orphanFilesRemoved: number;
+    /** Total bytes reclaimed by the unlinked files. */
+    bytesRemoved: number;
+}
+/**
+ * Resolves the package's own entry output files for the given file names,
+ * skipping any entry directory that resolves at or under `_dependencies/`.
+ *
+ * These are the reachability/usage roots: the chunks a consumer's package entry
+ * points actually load, from which dependency code is reached.
+ *
+ * @param context - Resolved build context supplying the entry points.
+ * @param depsRoot - Absolute path to the `_dependencies/` directory.
+ * @param fileNames - Output file names to look for in each entry directory
+ * (e.g. `['index.esm.js']`).
+ * @returns Absolute paths of every entry file that exists on disk.
+ *
+ * @example Collecting ESM entry roots
+ * ```typescript
+ * const roots = collectEntryFiles(context, depsRoot, ['index.esm.js'])
+ * ```
+ */
+export declare const collectEntryFiles: (context: BuildContext, depsRoot: string, fileNames: string[]) => string[];
+/**
+ * Recursively collects file paths under `dir` whose base name satisfies
+ * `matches`, appending them to `acc`.
+ *
+ * @param dir - Directory to walk; assumed to exist (the `_dependencies/` root or
+ * a directory yielded by `readDirectory`).
+ * @param matches - Predicate over a file's base name.
+ * @param acc - Accumulator that receives every matching absolute path.
+ *
+ * @example Gathering every ESM chunk
+ * ```typescript
+ * const chunks: string[] = []
+ * walkFiles(depsRoot, (name) => name === 'index.esm.js', chunks)
+ * ```
+ */
+export declare const walkFiles: (dir: string, matches: (name: string) => boolean, acc: string[]) => void;
+/**
+ * Orphan Sweep: deletes `_dependencies/**` chunk files that no package entry
+ * reaches.
+ *
+ * Runs reachability from the package's own entry output chunks over the
+ * `_dependencies/` JS graph, unlinks every `index.{esm,cjs}.js` (and `.map`
+ * sibling) that is unreachable, then applies the d.ts retention rule — a dep's
+ * `index.d.ts` is kept only when it is reachable from an entry's `.d.ts` graph.
+ * Entry `index.d.ts` are self-contained (dts-per-entry), so dep types no entry
+ * type-graph references are dead and removed. Empty directories left behind are
+ * removed. A dynamic, non-literal `import(`/`require(` anywhere in the reachable
+ * graph disables deletion entirely (guaranteed-safe fallback).
+ *
+ * @param context - Resolved build context.
+ * @param depsRoot - Absolute path to the `_dependencies/` directory.
+ * @returns Aggregate count of files removed and bytes reclaimed.
+ *
+ * @example Sweeping orphans after the per-entry d.ts pass
+ * ```typescript
+ * const { orphanFilesRemoved } = pruneOrphanChunks(context, depsRootOf(context))
+ * ```
+ */
+export declare const pruneOrphanChunks: (context: BuildContext, depsRoot: string) => OrphanPruneResult;
+//# sourceMappingURL=orphan-chunks.d.ts.map

package/bundle/dependencies/prune/orphan-chunks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orphan-chunks.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/prune/orphan-chunks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAQnD;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,oEAAoE;IACpE,kBAAkB,EAAE,MAAM,CAAA;IAC1B,mDAAmD;IACnD,YAAY,EAAE,MAAM,CAAA;CACrB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,iBAAiB,GAAI,SAAS,YAAY,EAAE,UAAU,MAAM,EAAE,WAAW,MAAM,EAAE,KAAG,MAAM,EAWtG,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,SAAS,GAAI,KAAK,MAAM,EAAE,SAAS,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,EAAE,KAAK,MAAM,EAAE,KAAG,IAM1F,CAAA;AAwDD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,GAAI,SAAS,YAAY,EAAE,UAAU,MAAM,KAAG,iBAU3E,CAAA"}

package/bundle/dependencies/prune/property-strip-pass.d.ts

@@ -0,0 +1,38 @@
+import type { BuildContext } from '../../../models';
+/**
+ * Aggregate result of the namespace property-strip pass.
+ */
+export interface PropertyStripPassResult {
+    /** Namespace slots removed across all chunks. */
+    deadPropertiesRemoved: number;
+    /** Bytes reclaimed by shrinking namespace literals. */
+    bytesRemoved: number;
+}
+/**
+ * Property-level tree-shaking of kept, live frozen namespace objects: drops the
+ * slots of an exported `freeze({ … })` namespace that no consumer in the whole
+ * graph ever reads, letting the dead-export pass then collapse the now-dead
+ * factory bindings.
+ *
+ * Runs per format (ESM and CJS) over `_dependencies/` chunks. The consumer graph
+ * is the package's entry chunks plus every sibling dependency chunk — a complete
+ * importer set, since per-entry bundling inlines all other first-party code.
+ * Each namespace's demand is the union of its `NS.prop` reads across that graph
+ * (in CJS, a two-level `require(...).NS.prop`); a wholesale consumption (spread,
+ * pass-through, enumeration, dynamic index, re-export, namespace/default import)
+ * or any dynamic specifier in the graph keeps the namespace whole. Only a
+ * namespace read at a strict, non-empty subset of its slots is rewritten. The
+ * caller is expected to re-run the dead-export pass afterwards to reclaim the
+ * orphaned factories.
+ *
+ * @param context - Resolved build context supplying the entry points.
+ * @param depsRoot - Absolute path to the `_dependencies/` directory.
+ * @returns Counts of slots removed and bytes reclaimed.
+ *
+ * @example Running the property strip before the dead-export re-pass
+ * ```typescript
+ * const { deadPropertiesRemoved } = stripDeadPropertiesPass(context, depsRootOf(context))
+ * ```
+ */
+export declare const stripDeadPropertiesPass: (context: BuildContext, depsRoot: string) => PropertyStripPassResult;
+//# sourceMappingURL=property-strip-pass.d.ts.map

package/bundle/dependencies/prune/property-strip-pass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"property-strip-pass.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/prune/property-strip-pass.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AA4BnD;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC,iDAAiD;IACjD,qBAAqB,EAAE,MAAM,CAAA;IAC7B,uDAAuD;IACvD,YAAY,EAAE,MAAM,CAAA;CACrB;AAuGD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,uBAAuB,GAAI,SAAS,YAAY,EAAE,UAAU,MAAM,KAAG,uBAKjF,CAAA"}

package/bundle/dependencies/prune/property-strip.d.ts

@@ -0,0 +1,69 @@
+import type { PropDemand } from './namespace-usage';
+import type { ChunkFormat } from './used-exports';
+/** Plain (node-free) description of a chunk's frozen namespace exports. */
+export interface NamespaceInfo {
+    /** The public export name. */
+    exported: string;
+    /** Property names the literal defines, in source order. */
+    properties: string[];
+}
+/** Analysis of one chunk: its namespace exports plus the demand its own body places on them. */
+export interface ChunkNamespaceAnalysis {
+    /** Frozen namespace exports found in the chunk. */
+    namespaces: NamespaceInfo[];
+    /** Demand the chunk's own statements place on its namespace exports (internal `NS.prop` reads or wholesale escapes). */
+    selfDemand: Map<string, PropDemand>;
+}
+/**
+ * Analyzes a single chunk for frozen namespace exports and the demand its own
+ * body places on them.
+ *
+ * Returns the namespace exports as node-free data (so the parsed source can be
+ * released) and a self-demand map folding every reference to a namespace's local
+ * binding outside its own declaration and export surface: a static `NS.prop`
+ * read contributes that property, any other use marks the namespace `'all'`.
+ *
+ * @param source - Raw chunk source text.
+ * @param format - Module format selecting the export shape.
+ * @returns The chunk's namespace exports and the demand it self-imposes.
+ *
+ * @example A chunk that exports a frozen namespace it never self-references
+ * ```typescript
+ * analyzeChunkNamespaces('const a = 1;\nconst NS = Object.freeze({ a });\nexport { a, NS };', 'esm')
+ * // => { namespaces: [{ exported: 'NS', properties: ['a'] }], selfDemand: Map {} }
+ * ```
+ */
+export declare const analyzeChunkNamespaces: (source: string, format: ChunkFormat) => ChunkNamespaceAnalysis;
+/**
+ * Outcome of stripping unread slots from a chunk's frozen namespace literals.
+ */
+export interface PropertyStripResult {
+    /** Rewritten chunk source with the unread slots removed from each namespace literal. */
+    code: string;
+    /** Number of slots removed across all namespaces in the chunk. */
+    removedProperties: number;
+}
+/**
+ * Rewrites a chunk's frozen namespace literals to keep only the slots the
+ * consumer graph reads, dropping the rest.
+ *
+ * For every exported frozen namespace, `keepByExport` supplies the property names
+ * to retain (the read set already intersected with the literal's own slots). A
+ * namespace absent from the map, or whose kept set is empty or covers every
+ * slot, is left untouched. Dropping a slot removes the only reference its factory
+ * binding had, so the subsequent dead-export pass collapses the now-dead
+ * factories — this pass only edits the literal.
+ *
+ * @param source - Raw chunk source text.
+ * @param format - Module format selecting the export shape.
+ * @param keepByExport - Per-export set of property names to retain.
+ * @returns The rewritten source and slot-removal count, or `null` when nothing changed.
+ *
+ * @example Keeping a single slot of a two-slot namespace
+ * ```typescript
+ * stripDeadProperties('const a=1;\nconst b=2;\nconst NS=Object.freeze({a,b});\nexport{NS};', 'esm', new Map([['NS', new Set(['a'])]]))
+ * // => literal rewritten to `{ a }`, removedProperties: 1
+ * ```
+ */
+export declare const stripDeadProperties: (source: string, format: ChunkFormat, keepByExport: Map<string, Set<string>>) => PropertyStripResult | null;
+//# sourceMappingURL=property-strip.d.ts.map

package/bundle/dependencies/prune/property-strip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"property-strip.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/prune/property-strip.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AA+BjD,2EAA2E;AAC3E,MAAM,WAAW,aAAa;IAC5B,8BAA8B;IAC9B,QAAQ,EAAE,MAAM,CAAA;IAChB,2DAA2D;IAC3D,UAAU,EAAE,MAAM,EAAE,CAAA;CACrB;AAED,gGAAgG;AAChG,MAAM,WAAW,sBAAsB;IACrC,mDAAmD;IACnD,UAAU,EAAE,aAAa,EAAE,CAAA;IAC3B,wHAAwH;IACxH,UAAU,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;CACpC;AAqDD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ,MAAM,EAAE,QAAQ,WAAW,KAAG,sBA2B5E,CAAA;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,wFAAwF;IACxF,IAAI,EAAE,MAAM,CAAA;IACZ,kEAAkE;IAClE,iBAAiB,EAAE,MAAM,CAAA;CAC1B;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,mBAAmB,GAC9B,QAAQ,MAAM,EACd,QAAQ,WAAW,EACnB,cAAc,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,KACrC,mBAAmB,GAAG,IAgBxB,CAAA"}

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

@@ -0,0 +1,52 @@
+import type { MemoryMonitor } from '../../../memory/monitor';
+import type { BuildContext } from '../../../models';
+/**
+ * Aggregate result of pruning dead dependency code from `_dependencies/`.
+ */
+export interface PruneReport {
+    /** Whole chunk files (and `.map`/`.d.ts.map` siblings) unlinked as orphans. */
+    orphanFilesRemoved: number;
+    /** Exported declarations spliced out of surviving chunks by the Export Strip. */
+    deadExportsRemoved: number;
+    /** Namespace slots spliced out of kept frozen-namespace literals by the Property Strip. */
+    deadPropertiesRemoved: number;
+    /** Whole-module CJS require bindings collapsed to destructures by the Destructure pass. */
+    requireBindingsDestructured: number;
+    /** Bytes reclaimed by the Comment Strip removing ordinary comments from surviving chunks. */
+    commentBytesRemoved: number;
+    /** Total bytes reclaimed across all removals. */
+    bytesRemoved: number;
+}
+/**
+ * Final, always-on bundle step that removes guaranteed-unused dependency code
+ * from `dist/libs/<pkg>/_dependencies/`.
+ *
+ * The pre-pass emits every hoisted dep at its full public-API surface; this
+ * step trims what the consuming package provably never reaches. The Orphan
+ * Sweep deletes whole orphan chunk files (JS + co-located d.ts) whose runtime is
+ * unreachable from the package's entry chunks. The Export Strip then strips dead
+ * exported declarations out of the surviving chunks. The Property Strip next
+ * drops the unread slots of any kept, live frozen-namespace object and a second
+ * Export Strip collapses the factories those slots held alive. A final sweep
+ * reclaims chunks left with no importer, since narrowing a chunk's imports can
+ * leave a sibling chunk unreferenced. The Destructure pass then collapses
+ * whole-module CJS `const NS = require(...)` bindings to destructuring binds
+ * wherever the binding is read only as static members and the edge is not in a
+ * `require` cycle. A final Comment Strip removes ordinary
+ * comments from the surviving chunks while preserving `@__PURE__` /
+ * `@__NO_SIDE_EFFECTS__` annotations and legal comments. Removal is conservative:
+ * anything whose removal cannot be proven safe — including the entire run when a
+ * dynamic specifier is present — is left untouched.
+ *
+ * @param context - Resolved build context. `outputPath` locates `_dependencies/`.
+ * @param monitor - Optional memory monitor; checkpoints are captured after the
+ * orphan sweep and after the dead-export pass so the step is observable.
+ * @returns Counts of files removed, dead exports removed, and bytes reclaimed.
+ *
+ * @example Pruning after the per-entry d.ts pass
+ * ```typescript
+ * const report = pruneDependencies(context, monitor)
+ * ```
+ */
+export declare const pruneDependencies: (context: BuildContext, monitor?: MemoryMonitor) => PruneReport;
+//# sourceMappingURL=prune-dependencies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prune-dependencies.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/prune/prune-dependencies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAA;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAWnD;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,+EAA+E;IAC/E,kBAAkB,EAAE,MAAM,CAAA;IAC1B,iFAAiF;IACjF,kBAAkB,EAAE,MAAM,CAAA;IAC1B,2FAA2F;IAC3F,qBAAqB,EAAE,MAAM,CAAA;IAC7B,2FAA2F;IAC3F,2BAA2B,EAAE,MAAM,CAAA;IACnC,6FAA6F;IAC7F,mBAAmB,EAAE,MAAM,CAAA;IAC3B,iDAAiD;IACjD,YAAY,EAAE,MAAM,CAAA;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,iBAAiB,GAAI,SAAS,YAAY,EAAE,UAAU,aAAa,KAAG,WA6ClF,CAAA"}

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

@@ -0,0 +1,36 @@
+/**
+ * Computes the set of files reachable from a set of root files by following
+ * literal relative specifiers, restricted to targets under `depsRoot`.
+ *
+ * Targets that resolve outside `depsRoot` (the package's own non-dependency
+ * code) are ignored; the roots themselves are always included so callers can use
+ * the returned set as a single live-membership oracle.
+ *
+ * If a reached file **under `depsRoot`** contains a dynamic (non-literal)
+ * `import(`/`require(`, the dependency chunk graph cannot be fully resolved, so
+ * the function logs and returns `null` — the guaranteed-safe sentinel that
+ * disables orphan deletion for the run. A dynamic specifier in a first-party
+ * **root** (which is never under `depsRoot`) is ignored: its target is always an
+ * external/user path, never a bundled dep chunk, so it cannot hide a
+ * `_dependencies/` edge — bailing on it would needlessly strand emptied dep
+ * chunks the sweep should reclaim.
+ *
+ * @param roots - Absolute paths to the root files reachability starts from.
+ * @param depsRoot - Absolute path to the `_dependencies/` directory; traversal
+ * never leaves it.
+ * @param resolveTarget - Maps each resolved specifier target before it is
+ * visited; defaults to identity. The d.ts pass passes a mapper that rewrites a
+ * runtime specifier (`'.../index.js'`) to its declaration sibling
+ * (`'.../index.d.ts'`) so traversal follows the type graph, never the runtime
+ * graph.
+ * @returns The set of reachable absolute file paths, or `null` when a dynamic
+ * specifier forces a safety bail.
+ *
+ * @example Reachability from an ESM entry chunk
+ * ```typescript
+ * const live = computeReachable(['/dist/libs/foo/index.esm.js'], '/dist/libs/foo/_dependencies')
+ * if (live && !live.has(orphanChunk)) unlinkSync(orphanChunk)
+ * ```
+ */
+export declare const computeReachable: (roots: string[], depsRoot: string, resolveTarget?: (target: string) => string) => Set<string> | null;
+//# sourceMappingURL=reachability.d.ts.map

package/bundle/dependencies/prune/reachability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reachability.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/prune/reachability.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,gBAAgB,GAC3B,OAAO,MAAM,EAAE,EACf,UAAU,MAAM,EAChB,gBAAe,CAAC,MAAM,EAAE,MAAM,KAAK,MAA2B,KAC7D,GAAG,CAAC,MAAM,CAAC,GAAG,IA6BhB,CAAA"}

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

@@ -0,0 +1,39 @@
+/**
+ * Extracts literal **relative** module specifiers referenced by a chunk's source.
+ *
+ * Scans ESM `from '…'` (covering both `import … from` and `export … from`),
+ * CJS `require('…')`, and literal dynamic `import('…')`. Only specifiers that
+ * start with `.` are returned — bare and node-builtin specifiers are never
+ * edges into the `_dependencies/` tree. The scan deliberately over-approximates
+ * (a spurious match merely keeps a chunk alive), so it is implemented with
+ * linear, backtracking-free regexes rather than a full parse.
+ *
+ * @param source - Raw chunk source text.
+ * @returns Unique relative specifiers, in first-seen order.
+ *
+ * @example Extracting the sibling chunks a CJS chunk requires
+ * ```typescript
+ * collectChunkSpecifiers("require('../shared/index.cjs.js')") // => ['../shared/index.cjs.js']
+ * ```
+ */
+export declare const collectChunkSpecifiers: (source: string) => string[];
+/**
+ * Reports whether a chunk contains a dynamic `import(…)` or `require(…)` whose
+ * argument is not a string literal.
+ *
+ * Used as a safety bail: a dynamic specifier cannot be statically resolved, so
+ * reachability over the chunk graph would be incomplete and orphan deletion
+ * unsafe. When this returns `true` the caller disables Orphan Sweep deletion for the
+ * run. A concatenated argument such as `'@rollup/rollup-' + platform` counts as
+ * dynamic even though it begins with a string literal.
+ *
+ * @param source - Raw chunk source text.
+ * @returns `true` if at least one non-literal `import(`/`require(` call exists.
+ *
+ * @example Detecting a computed require
+ * ```typescript
+ * hasDynamicSpecifier("require('@rollup/rollup-' + platform)") // => true
+ * ```
+ */
+export declare const hasDynamicSpecifier: (source: string) => boolean;
+//# sourceMappingURL=specifiers.d.ts.map

package/bundle/dependencies/prune/specifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"specifiers.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/prune/specifiers.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,sBAAsB,GAAI,QAAQ,MAAM,KAAG,MAAM,EAM7D,CAAA;AAwBD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,mBAAmB,GAAI,QAAQ,MAAM,KAAG,OAMpD,CAAA"}

package/bundle/dependencies/prune/strip-comments.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Outcome of the Comment Strip.
+ */
+export interface CommentStripResult {
+    /** Bytes reclaimed by removing ordinary comments from surviving chunks. */
+    commentBytesRemoved: number;
+}
+/**
+ * Strips ordinary comments from `source`, preserving `@__PURE__` /
+ * `@__NO_SIDE_EFFECTS__` and legal comments. Returns the rewritten text, or
+ * `null` when there is nothing removable (leaving the file untouched and the pass
+ * idempotent on a second run).
+ *
+ * @param source - Raw chunk source to strip.
+ * @returns The rewritten source, or `null` when nothing is removable.
+ *
+ * @example Stripping a chunk's JSDoc while keeping its `@__PURE__` annotations
+ * ```typescript
+ * const stripped = stripComments(readFileContent(chunk))
+ * if (stripped !== null) writeFileContent(chunk, stripped)
+ * ```
+ */
+export declare const stripComments: (source: string) => string | null;
+/**
+ * Comment Strip: removes ordinary comments — source banners, `eslint-disable`
+ * pragmas, and full JSDoc — from every surviving `_dependencies/**` runtime chunk
+ * while preserving `@__PURE__` / `@__NO_SIDE_EFFECTS__` annotations and legal
+ * comments.
+ *
+ * Consumers read the package's public `index.d.ts`, never `_dependencies/**\/*.js`,
+ * so these comments are pure runtime bytes — but the annotations a downstream
+ * bundler uses to tree-shake our package and the legal comments it must surface
+ * really do ship inside the chunks, so the strip is a comment-aware text splice
+ * (no minify, no reformat), not a blanket removal. A `ts.Scanner` enumerates
+ * genuine comment trivia, keeping comment-looking text inside strings, templates,
+ * and regex literals untouched.
+ *
+ * @param depsRoot - Absolute path to the `_dependencies/` directory.
+ * @returns Bytes reclaimed across all chunks.
+ *
+ * @example Stripping comments after the prune passes
+ * ```typescript
+ * const { commentBytesRemoved } = stripCommentsPass(depsRootOf(context))
+ * ```
+ */
+export declare const stripCommentsPass: (depsRoot: string) => CommentStripResult;
+//# sourceMappingURL=strip-comments.d.ts.map

package/bundle/dependencies/prune/strip-comments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strip-comments.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/prune/strip-comments.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,2EAA2E;IAC3E,mBAAmB,EAAE,MAAM,CAAA;CAC5B;AA6HD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,MAAM,KAAG,MAAM,GAAG,IAQvD,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,GAAI,UAAU,MAAM,KAAG,kBAapD,CAAA"}

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

@@ -0,0 +1,32 @@
+/**
+ * Per-chunk usage demand from a single importer set: either the concrete set of
+ * exported names referenced, or `'all'` — the safety sentinel meaning the
+ * importer consumes the chunk wholesale (namespace/default import, or a `require`
+ * binding escaping member access) so nothing may be stripped.
+ */
+export type ImportUsage = Set<string> | 'all';
+/** Module output format of the chunks being analyzed. */
+export type ChunkFormat = 'esm' | 'cjs';
+/**
+ * Builds the map of chunk → exported-name demand for every relative module edge
+ * a single importer declares.
+ *
+ * Each key is the absolute path the importer references; each value is the set
+ * of exported names it pulls from that chunk, or `'all'` when the reference is
+ * wholesale (namespace/default import, `export *`, or a `require` binding that
+ * escapes member access). A side-effect-only `import './x'` records the target
+ * with an empty set.
+ *
+ * @param source - Raw importer source text.
+ * @param importerDir - Absolute directory of the importer file.
+ * @param format - Module format that determines ESM vs CJS edge extraction.
+ * @returns Map from resolved chunk path to its usage demand.
+ *
+ * @example Edges of an ESM entry
+ * ```typescript
+ * collectImportEdges("import { getType } from './_dependencies/x/index.esm.js'", '/dist/libs/foo', 'esm')
+ * // => Map { '/dist/libs/foo/_dependencies/x/index.esm.js' => Set { 'getType' } }
+ * ```
+ */
+export declare const collectImportEdges: (source: string, importerDir: string, format: ChunkFormat) => Map<string, ImportUsage>;
+//# sourceMappingURL=used-exports.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"used-exports.d.ts","sourceRoot":"","sources":["../../../../../../../../../libs/builder/src/bundle/dependencies/prune/used-exports.ts"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,GAAG,KAAK,CAAA;AAE7C,yDAAyD;AACzD,MAAM,MAAM,WAAW,GAAG,KAAK,GAAG,KAAK,CAAA;AA2IvC;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,kBAAkB,GAAI,QAAQ,MAAM,EAAE,aAAa,MAAM,EAAE,QAAQ,WAAW,KAAG,GAAG,CAAC,MAAM,EAAE,WAAW,CAMpH,CAAA"}

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

@@ -0,0 +1,37 @@
+import type { IsWorkspacePackagePredicate } from '../../models';
+/**
+ * Inputs to {@link resolveBundledDeps}.
+ */
+export interface ResolveBundledDepsOptions {
+    /** Predicate identifying workspace-internal packages; when matched, packages are NOT pre-passed. */
+    isWorkspacePackage?: IsWorkspacePackagePredicate;
+    /** Force-include packages even if absent from `package.json#dependencies`. */
+    include?: string[];
+    /** Skip these packages even if otherwise selected. */
+    exclude?: string[];
+}
+/**
+ * Resolves the list of third-party dependencies that should be pre-passed
+ * (bundled once into `_dependencies/<dep>/`) for the build.
+ *
+ * Algorithm:
+ * 1. Read `dependencies` from the project's `package.json`.
+ * 2. Subtract `peerDependencies` — those stay external.
+ * 3. Subtract anything matching `isWorkspacePackage` — workspace deps are inlined per the existing flow.
+ * 4. Apply `include` / `exclude` overrides.
+ *
+ * The returned list is sorted and de-duplicated.
+ *
+ * @param packageJsonPath - Absolute path to the project's `package.json`.
+ * @param options - Caller overrides.
+ * @returns Sorted list of third-party package names to pre-pass.
+ *
+ * @example Resolving bundled deps for a workspace library
+ * ```typescript
+ * const deps = resolveBundledDeps('/abs/libs/foo/package.json', {
+ *   isWorkspacePackage: (n) => n.startsWith('@hyperfrontend/'),
+ * })
+ * ```
+ */
+export declare const resolveBundledDeps: (packageJsonPath: string, options?: ResolveBundledDepsOptions) => string[];
+//# sourceMappingURL=resolve-bundled-deps.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-bundled-deps.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/dependencies/resolve-bundled-deps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,2BAA2B,EAAe,MAAM,cAAc,CAAA;AAiB5E;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,oGAAoG;IACpG,kBAAkB,CAAC,EAAE,2BAA2B,CAAA;IAChD,8EAA8E;IAC9E,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CACnB;AAID;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,eAAO,MAAM,kBAAkB,GAAI,iBAAiB,MAAM,EAAE,UAAS,yBAA8B,KAAG,MAAM,EAc3G,CAAA"}

package/bundle/dependencies/resolve-dep-entry.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Inputs to {@link resolveDepEntry}.
+ */
+export interface ResolveDepEntryOptions {
+    /** Dep package name, e.g. `"rollup"` or `"@rollup/plugin-typescript"`. */
+    dep: string;
+    /** Absolute project root (used to anchor the dep's `package.json` lookup). */
+    projectRoot: string;
+    /** Absolute workspace root, used as a secondary lookup root. */
+    workspaceRoot: string;
+    /**
+     * Pre-pass kind:
+     * - `'js'` — return the dep's runtime entry (`module` / `main`).
+     * - `'dts'` — return the dep's types entry (`types` / `typings`).
+     */
+    kind: 'js' | 'dts';
+}
+/**
+ * Resolves the absolute path to a bundled dep's entry file (JS or `.d.ts`) for a
+ * pre-pass invocation.
+ *
+ * For JS jobs the resolution prefers the dep's `module` field (ESM) over `main`
+ * (CJS). For dts jobs it prefers `types` over `typings`. Lookup walks the project
+ * root first, then the workspace root, using `createRequire` so node's standard
+ * resolution semantics apply (including support for hoisted `node_modules`).
+ *
+ * @param options - Dep name, root paths, and kind.
+ * @returns Absolute path to the dep's entry file.
+ * @throws {Error} When the dep's `package.json` cannot be located or it lacks the
+ * required entry field.
+ *
+ * @example Resolving the runtime entry for `rollup`
+ * ```typescript
+ * const entry = resolveDepEntry({ dep: 'rollup', projectRoot, workspaceRoot, kind: 'js' })
+ * ```
+ */
+export declare const resolveDepEntry: (options: ResolveDepEntryOptions) => string;
+//# sourceMappingURL=resolve-dep-entry.d.ts.map

package/bundle/dependencies/resolve-dep-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-dep-entry.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/bundle/dependencies/resolve-dep-entry.ts"],"names":[],"mappings":"AAyCA;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,0EAA0E;IAC1E,GAAG,EAAE,MAAM,CAAA;IACX,8EAA8E;IAC9E,WAAW,EAAE,MAAM,CAAA;IACnB,gEAAgE;IAChE,aAAa,EAAE,MAAM,CAAA;IACrB;;;;OAIG;IACH,IAAI,EAAE,IAAI,GAAG,KAAK,CAAA;CACnB;AAwDD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,sBAAsB,KAAG,MASjE,CAAA"}