@hyperfrontend/builder 0.1.0

package/package/json/generate-exports.d.ts

@@ -0,0 +1,29 @@
+import type { EntryPointDiscovery, ExportValue, FormatOutputs, PackageJson } from '../../models';
+/**
+ * Generates the published `exports` field by aligning the source `package.json`
+ * declaration with the actual format outputs the bundle phase produced.
+ *
+ * Strategy is **source-exports first**: every key declared on `srcPkg.exports`
+ * is mapped to a conditional export entry built from the formats that actually
+ * landed for the matching subpath. Internal modules that were built but not
+ * advertised in the source `exports` map are intentionally omitted from the
+ * published output.
+ *
+ * If `srcPkg` has no `exports` field, falls back to a single root-entry export
+ * synthesized from `discovery.hasRootEntry`.
+ *
+ * IIFE / UMD CDN bundles are **not** advertised in `exports`; they are reached
+ * solely through the `unpkg`/`jsdelivr` fields (see {@link getCdnPaths}).
+ *
+ * @param discovery - Entry-point discovery result produced earlier in the pipeline.
+ * @param formatOutputs - Aggregated outputs collected by the bundle phase.
+ * @param srcPkg - Source `package.json` whose `exports` map drives advertised subpaths.
+ * @returns A new `exports` map suitable for the published `package.json`.
+ *
+ * @example Generating exports honoring source aliases
+ * ```typescript
+ * const exports = generateExportsFromFormats(discovery, formatOutputs, srcPkg)
+ * ```
+ */
+export declare const generateExportsFromFormats: (discovery: EntryPointDiscovery, formatOutputs: FormatOutputs, srcPkg?: PackageJson) => Record<string, ExportValue>;
+//# sourceMappingURL=generate-exports.d.ts.map

package/package/json/generate-exports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-exports.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/package/json/generate-exports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAqB,mBAAmB,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAqCnH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,0BAA0B,GACrC,WAAW,mBAAmB,EAC9B,eAAe,aAAa,EAC5B,SAAS,WAAW,KACnB,MAAM,CAAC,MAAM,EAAE,WAAW,CA6B5B,CAAA"}

package/package/json/index.cjs.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const index_cjs_js$1 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/object/index.cjs.js');
+const index_cjs_js = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/set/index.cjs.js');
+const index_cjs_js$2 = require('../../_dependencies/@hyperfrontend/project-scope/core/index.cjs.js');
+const index_cjs_js$3 = require('../../_dependencies/@hyperfrontend/immutable-api-utils/built-in-copy/array/index.cjs.js');
+const { reflectFilesAllowlist } = require('../../_shared/package/json/reflect-files-allowlist/index.cjs.js');
+const { writeOutputPackageJson } = require('../../_shared/package/json/write/index.cjs.js');
+const { readProjectPackageJson } = require('../../_shared/package/json/read-package-json/index.cjs.js');
+const { getCdnPaths } = require('../../_shared/package/json/cdn-paths/index.cjs.js');
+const { filterWorkspaceDepsFromOutput, filterBundledDepsFromOutput } = require('../../_shared/package/json/filter-deps/index.cjs.js');
+const { generateExportsFromFormats } = require('../../_shared/package/json/generate-exports/index.cjs.js');
+const { inheritFields } = require('../../_shared/package/json/inherit-fields/index.cjs.js');
+const { synthesizePackageJson } = require('../../_shared/package/json/synthesize/index.cjs.js');
+
+exports.filterBundledDepsFromOutput = filterBundledDepsFromOutput;
+exports.filterWorkspaceDepsFromOutput = filterWorkspaceDepsFromOutput;
+exports.generateExportsFromFormats = generateExportsFromFormats;
+exports.getCdnPaths = getCdnPaths;
+exports.inheritFields = inheritFields;
+exports.readProjectPackageJson = readProjectPackageJson;
+exports.reflectFilesAllowlist = reflectFilesAllowlist;
+exports.synthesizePackageJson = synthesizePackageJson;
+exports.writeOutputPackageJson = writeOutputPackageJson;

package/package/json/index.d.ts

@@ -0,0 +1,252 @@
+import { FormatOutputs, InheritFromSpec, IsWorkspacePackagePredicate, BinConfig, PackageJson, BuildContext, EntryPointDiscovery, ExportValue } from '../../models';
+
+/**
+ * Resolved CDN paths for `unpkg` and `jsdelivr` package.json fields.
+ */
+interface CdnPaths {
+    /** Path advertised on the `unpkg` field. */
+    unpkg: string;
+    /** Path advertised on the `jsdelivr` field. */
+    jsdelivr: string;
+}
+/**
+ * Optional overrides accepted by {@link getCdnPaths}.
+ */
+interface CdnPathOverrides {
+    /** Explicit path for the `unpkg` field. */
+    unpkg?: string;
+    /** Explicit path for the `jsdelivr` field. */
+    jsdelivr?: string;
+}
+/**
+ * Computes the CDN entry paths advertised on the published `package.json`.
+ *
+ * Priority order:
+ * 1. Explicit `opts.unpkg` / `opts.jsdelivr` overrides win for their respective field.
+ * 2. The first UMD bundle, when one was emitted, supplies the default path.
+ * 3. The first IIFE bundle is used when no UMD bundle exists.
+ * 4. When no UMD or IIFE bundles were produced, returns `undefined` so callers can
+ *    skip emitting the fields entirely.
+ *
+ * @param formatOutputs - Aggregated bundle-phase output.
+ * @param opts - Optional explicit overrides for either CDN field.
+ * @returns Resolved CDN paths or `undefined` when no CDN-eligible bundle was produced.
+ *
+ * @example Resolving CDN paths from a UMD-only build
+ * ```typescript
+ * const cdn = getCdnPaths(formatOutputs)
+ * // → { unpkg: './bundle/index.umd.min.js', jsdelivr: './bundle/index.umd.min.js' }
+ * ```
+ */
+declare const getCdnPaths: (formatOutputs: FormatOutputs, opts?: CdnPathOverrides) => CdnPaths | undefined;
+
+/**
+ * Options consumed by {@link synthesizePackageJson}.
+ */
+interface SynthesizePackageJsonOptions {
+    /** Selectively copy fields from another `package.json` onto the output. */
+    inheritFieldsFrom?: InheritFromSpec;
+    /** Strip workspace-internal entries from the output `dependencies` map. */
+    filterWorkspaceDepsFromOutput?: boolean;
+    /** Predicate identifying workspace-internal packages; required when filtering is enabled. */
+    isWorkspacePackage?: IsWorkspacePackagePredicate;
+    /** Override path for the `unpkg` field. */
+    unpkg?: string;
+    /** Override path for the `jsdelivr` field. */
+    jsdelivr?: string;
+    /** Bin declarations from the build config; drives `package.json#bin` synthesis. */
+    bins?: BinConfig[];
+    /** Allowlist for `package.json#files`; emitted verbatim when non-empty. */
+    files?: string[];
+}
+/**
+ * Composes the published `package.json` from the source manifest, the bundle-phase
+ * outputs, and caller-supplied options.
+ *
+ * Pipeline order is: filter workspace deps → apply inherited fields → assemble
+ * the new manifest with `sideEffects: false`, the regenerated `exports` map, and
+ * resolved `main` / `module` / `types` pointers; CDN fields are appended only
+ * when a UMD or IIFE bundle was emitted; the `bin` field is synthesized from
+ * the supplied bin declarations using deterministic naming rules; the `files`
+ * allowlist is forwarded verbatim when supplied.
+ *
+ * Root-pointers (`main`, `module`, `types`) are removed entirely when the
+ * library has no root entry, so consumers cannot resolve a non-existent default.
+ *
+ * @param srcPkg - Source `package.json` parsed from the project root.
+ * @param ctx - Resolved build context (used for the entry-point discovery shape).
+ * @param formatOutputs - Aggregated outputs collected by the bundle phase.
+ * @param opts - Inheritance / filter / CDN-override / bin / files toggles.
+ * @returns The fully assembled `PackageJson` ready to be written to the dist root.
+ *
+ * @example Synthesizing the dist package.json for a library with workspace inlining
+ * ```typescript
+ * const distPkg = synthesizePackageJson(srcPkg, ctx, formatOutputs, {
+ *   inheritFieldsFrom: { from: '/abs/repo/package.json', fields: ['repository', 'bugs'] },
+ *   filterWorkspaceDepsFromOutput: true,
+ *   isWorkspacePackage: (n) => n.startsWith('@hyperfrontend/'),
+ *   bins: [{ name: 'hf-build', format: ['cjs'] }],
+ *   files: ['_dependencies/', 'bin/', 'index.*'],
+ * })
+ * ```
+ */
+declare const synthesizePackageJson: (srcPkg: PackageJson, ctx: BuildContext, formatOutputs: FormatOutputs, opts?: SynthesizePackageJsonOptions) => PackageJson;
+
+/**
+ * Returns a new `PackageJson` with workspace-internal entries stripped from
+ * `dependencies`. `peerDependencies` and `optionalDependencies` are preserved
+ * verbatim so consumers retain optional integrations.
+ *
+ * If filtering empties the `dependencies` map, the field is removed from the
+ * returned object instead of left as `{}`.
+ *
+ * @param pkg - Source `PackageJson` to filter.
+ * @param isWorkspacePackage - Predicate returning `true` for workspace-internal packages.
+ * @returns Filtered `PackageJson` clone.
+ *
+ * @example Stripping `@hyperfrontend/*` deps before publishing
+ * ```typescript
+ * const filtered = filterWorkspaceDepsFromOutput(srcPkg, byPrefix('@hyperfrontend/'))
+ * ```
+ */
+declare const filterWorkspaceDepsFromOutput: (pkg: PackageJson, isWorkspacePackage: IsWorkspacePackagePredicate) => PackageJson;
+/**
+ * Returns a new `PackageJson` with bundled-dep entries stripped from `dependencies`.
+ *
+ * When the dist contains pre-passed copies under `_dependencies/<dep>/`, those packages
+ * are no longer transitive runtime requirements — consumers get them inside the tarball.
+ * Removing them from the published `dependencies` field keeps the manifest honest.
+ *
+ * If filtering empties the `dependencies` map, the field is removed entirely.
+ *
+ * @param pkg - Source `PackageJson` to filter.
+ * @param bundledDeps - Bundled-dep package names (typically `BuildContext.bundledDeps`).
+ * @returns Filtered `PackageJson` clone.
+ *
+ * @example Stripping bundled deps from the published dependencies map
+ * ```typescript
+ * const filtered = filterBundledDepsFromOutput(srcPkg, ['rollup', 'postject'])
+ * ```
+ */
+declare const filterBundledDepsFromOutput: (pkg: PackageJson, bundledDeps: string[]) => PackageJson;
+
+/**
+ * Generates the published `exports` field by aligning the source `package.json`
+ * declaration with the actual format outputs the bundle phase produced.
+ *
+ * Strategy is **source-exports first**: every key declared on `srcPkg.exports`
+ * is mapped to a conditional export entry built from the formats that actually
+ * landed for the matching subpath. Internal modules that were built but not
+ * advertised in the source `exports` map are intentionally omitted from the
+ * published output.
+ *
+ * If `srcPkg` has no `exports` field, falls back to a single root-entry export
+ * synthesized from `discovery.hasRootEntry`.
+ *
+ * IIFE / UMD CDN bundles are **not** advertised in `exports`; they are reached
+ * solely through the `unpkg`/`jsdelivr` fields (see {@link getCdnPaths}).
+ *
+ * @param discovery - Entry-point discovery result produced earlier in the pipeline.
+ * @param formatOutputs - Aggregated outputs collected by the bundle phase.
+ * @param srcPkg - Source `package.json` whose `exports` map drives advertised subpaths.
+ * @returns A new `exports` map suitable for the published `package.json`.
+ *
+ * @example Generating exports honoring source aliases
+ * ```typescript
+ * const exports = generateExportsFromFormats(discovery, formatOutputs, srcPkg)
+ * ```
+ */
+declare const generateExportsFromFormats: (discovery: EntryPointDiscovery, formatOutputs: FormatOutputs, srcPkg?: PackageJson) => Record<string, ExportValue>;
+
+/**
+ * Returns a new `PackageJson` with the requested top-level fields copied from
+ * the source described by `spec` onto `target`.
+ *
+ * The merge is intentionally shallow: only fields named in `spec.fields` are
+ * considered, and the original `target` value wins when the source field is
+ * missing or `undefined`. The function is a no-op (returns `target` unchanged)
+ * when `spec` is omitted, and silently returns `target` when the source file
+ * does not exist on disk.
+ *
+ * @param target - Package.json being assembled for the published artifact.
+ * @param spec - Optional inheritance specification: source path + field names to copy.
+ * @returns A new `PackageJson` with inherited fields applied.
+ *
+ * @example Inheriting `repository`, `bugs`, and `author` from the workspace root
+ * ```typescript
+ * const merged = inheritFields(srcPkg, {
+ *   from: '/abs/repo/package.json',
+ *   fields: ['repository', 'bugs', 'author'],
+ * })
+ * ```
+ */
+declare const inheritFields: (target: PackageJson, spec?: InheritFromSpec) => PackageJson;
+
+/**
+ * Reads and parses the project's `package.json` from the given project root.
+ *
+ * The file is required to exist; missing files surface as the standard
+ * `FS_NOT_FOUND` filesystem error from project-scope.
+ *
+ * @param projectRoot - Absolute path to the project root containing `package.json`.
+ * @returns Parsed `package.json` contents typed as `PackageJson`.
+ *
+ * @example Reading the source package.json before synthesizing the dist version
+ * ```typescript
+ * const srcPkg = readProjectPackageJson('/abs/libs/foo')
+ * console.log(srcPkg.name)
+ * ```
+ */
+declare const readProjectPackageJson: (projectRoot: string) => PackageJson;
+
+/**
+ * Reflects a materialized publishable output tree into a `package.json#files`
+ * allowlist.
+ *
+ * Derives `files` from what the build actually emitted: the two index globs
+ * cover every entrypoint `index.*`/`index.d.ts` at any depth, and every
+ * surviving non-index file is named explicitly by its package-root-relative
+ * POSIX path (no `<dir>/` buckets). Run after every emit phase and the
+ * orphan-prune so the walk sees exactly the tree that ships; the allowlist is
+ * then correct by construction.
+ *
+ * The root `package.json` is skipped (npm always includes it) and `index.*`
+ * files are skipped (covered by the glob); metadata files (README, LICENSE,
+ * THIRD_PARTY_LICENSES, …) are picked up by the walk only when present.
+ *
+ * The sorted positive entries are followed by {@link JS_MAP_EXCLUDE_GLOB} — a
+ * trailing negation that subtracts any JS sourcemap the index glob would
+ * otherwise ship. It must come last (npm resolves `files` last-match-wins), so
+ * it is appended after the sort rather than folded into the sorted set.
+ *
+ * @param outputPath - Absolute path to the materialized publishable output root.
+ * @returns Sorted, deduped positive allowlist entries, then the trailing JS-map
+ *   exclusion, for `package.json#files`.
+ *
+ * @example Reflecting a built library's output tree
+ * ```typescript
+ * const files = reflectFilesAllowlist(ctx.outputPath)
+ * // => the two index globs, then 'README.md', 'models.d.ts', 'bin/hf-build.js', …, '!**\/*.js.map'
+ * ```
+ */
+declare const reflectFilesAllowlist: (outputPath: string) => string[];
+
+/**
+ * Writes the synthesized `package.json` to the build output directory.
+ *
+ * The file is emitted with two-space indentation (project-scope's default) and
+ * a trailing newline so the published artifact diffs cleanly against
+ * formatter-managed source files.
+ *
+ * @param outputPath - Absolute path to the output directory (the dist root).
+ * @param packageJson - Fully assembled `PackageJson` to serialize.
+ *
+ * @example Writing the dist package.json
+ * ```typescript
+ * writeOutputPackageJson(ctx.outputPath, distPkg)
+ * ```
+ */
+declare const writeOutputPackageJson: (outputPath: string, packageJson: PackageJson) => void;
+
+export { filterBundledDepsFromOutput, filterWorkspaceDepsFromOutput, generateExportsFromFormats, getCdnPaths, inheritFields, readProjectPackageJson, reflectFilesAllowlist, synthesizePackageJson, writeOutputPackageJson };
+export type { CdnPathOverrides, CdnPaths, SynthesizePackageJsonOptions };

package/package/json/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/package/json/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,YAAY,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAC7D,YAAY,EAAE,4BAA4B,EAAE,MAAM,cAAc,CAAA;AAChE,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AACzC,OAAO,EAAE,2BAA2B,EAAE,6BAA6B,EAAE,MAAM,eAAe,CAAA;AAC1F,OAAO,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAA;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAChD,OAAO,EAAE,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAA;AACjE,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA"}

package/package/json/index.esm.js

@@ -0,0 +1,14 @@
+import { entries, fromEntries, 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, join, readDirectory, relativePath, matchGlobPattern, writeJsonFile } 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 { reflectFilesAllowlist } from '../../_shared/package/json/reflect-files-allowlist/index.esm.js';
+import { writeOutputPackageJson } from '../../_shared/package/json/write/index.esm.js';
+import { readProjectPackageJson } from '../../_shared/package/json/read-package-json/index.esm.js';
+import { getCdnPaths } from '../../_shared/package/json/cdn-paths/index.esm.js';
+import { filterWorkspaceDepsFromOutput, filterBundledDepsFromOutput } from '../../_shared/package/json/filter-deps/index.esm.js';
+import { generateExportsFromFormats } from '../../_shared/package/json/generate-exports/index.esm.js';
+import { inheritFields } from '../../_shared/package/json/inherit-fields/index.esm.js';
+import { synthesizePackageJson } from '../../_shared/package/json/synthesize/index.esm.js';
+
+export { filterBundledDepsFromOutput, filterWorkspaceDepsFromOutput, generateExportsFromFormats, getCdnPaths, inheritFields, readProjectPackageJson, reflectFilesAllowlist, synthesizePackageJson, writeOutputPackageJson };

package/package/json/inherit-fields.d.ts

@@ -0,0 +1,25 @@
+import type { InheritFromSpec, PackageJson } from '../../models';
+/**
+ * Returns a new `PackageJson` with the requested top-level fields copied from
+ * the source described by `spec` onto `target`.
+ *
+ * The merge is intentionally shallow: only fields named in `spec.fields` are
+ * considered, and the original `target` value wins when the source field is
+ * missing or `undefined`. The function is a no-op (returns `target` unchanged)
+ * when `spec` is omitted, and silently returns `target` when the source file
+ * does not exist on disk.
+ *
+ * @param target - Package.json being assembled for the published artifact.
+ * @param spec - Optional inheritance specification: source path + field names to copy.
+ * @returns A new `PackageJson` with inherited fields applied.
+ *
+ * @example Inheriting `repository`, `bugs`, and `author` from the workspace root
+ * ```typescript
+ * const merged = inheritFields(srcPkg, {
+ *   from: '/abs/repo/package.json',
+ *   fields: ['repository', 'bugs', 'author'],
+ * })
+ * ```
+ */
+export declare const inheritFields: (target: PackageJson, spec?: InheritFromSpec) => PackageJson;
+//# sourceMappingURL=inherit-fields.d.ts.map

package/package/json/inherit-fields.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inherit-fields.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/package/json/inherit-fields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAGhE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,aAAa,GAAI,QAAQ,WAAW,EAAE,OAAO,eAAe,KAAG,WAU3E,CAAA"}

package/package/json/read-package-json.d.ts

@@ -0,0 +1,18 @@
+import type { PackageJson } from '../../models';
+/**
+ * Reads and parses the project's `package.json` from the given project root.
+ *
+ * The file is required to exist; missing files surface as the standard
+ * `FS_NOT_FOUND` filesystem error from project-scope.
+ *
+ * @param projectRoot - Absolute path to the project root containing `package.json`.
+ * @returns Parsed `package.json` contents typed as `PackageJson`.
+ *
+ * @example Reading the source package.json before synthesizing the dist version
+ * ```typescript
+ * const srcPkg = readProjectPackageJson('/abs/libs/foo')
+ * console.log(srcPkg.name)
+ * ```
+ */
+export declare const readProjectPackageJson: (projectRoot: string) => PackageJson;
+//# sourceMappingURL=read-package-json.d.ts.map

package/package/json/read-package-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"read-package-json.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/package/json/read-package-json.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAG/C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,sBAAsB,GAAI,aAAa,MAAM,KAAG,WAA2E,CAAA"}

package/package/json/reflect-files-allowlist.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Reflects a materialized publishable output tree into a `package.json#files`
+ * allowlist.
+ *
+ * Derives `files` from what the build actually emitted: the two index globs
+ * cover every entrypoint `index.*`/`index.d.ts` at any depth, and every
+ * surviving non-index file is named explicitly by its package-root-relative
+ * POSIX path (no `<dir>/` buckets). Run after every emit phase and the
+ * orphan-prune so the walk sees exactly the tree that ships; the allowlist is
+ * then correct by construction.
+ *
+ * The root `package.json` is skipped (npm always includes it) and `index.*`
+ * files are skipped (covered by the glob); metadata files (README, LICENSE,
+ * THIRD_PARTY_LICENSES, …) are picked up by the walk only when present.
+ *
+ * The sorted positive entries are followed by {@link JS_MAP_EXCLUDE_GLOB} — a
+ * trailing negation that subtracts any JS sourcemap the index glob would
+ * otherwise ship. It must come last (npm resolves `files` last-match-wins), so
+ * it is appended after the sort rather than folded into the sorted set.
+ *
+ * @param outputPath - Absolute path to the materialized publishable output root.
+ * @returns Sorted, deduped positive allowlist entries, then the trailing JS-map
+ *   exclusion, for `package.json#files`.
+ *
+ * @example Reflecting a built library's output tree
+ * ```typescript
+ * const files = reflectFilesAllowlist(ctx.outputPath)
+ * // => the two index globs, then 'README.md', 'models.d.ts', 'bin/hf-build.js', …, '!**\/*.js.map'
+ * ```
+ */
+export declare const reflectFilesAllowlist: (outputPath: string) => string[];
+//# sourceMappingURL=reflect-files-allowlist.d.ts.map

package/package/json/reflect-files-allowlist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reflect-files-allowlist.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/package/json/reflect-files-allowlist.ts"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,qBAAqB,GAAI,YAAY,MAAM,KAAG,MAAM,EAmBhE,CAAA"}

package/package/json/synthesize.d.ts

@@ -0,0 +1,53 @@
+import type { BinConfig, BuildContext, FormatOutputs, InheritFromSpec, IsWorkspacePackagePredicate, PackageJson } from '../../models';
+/**
+ * Options consumed by {@link synthesizePackageJson}.
+ */
+export interface SynthesizePackageJsonOptions {
+    /** Selectively copy fields from another `package.json` onto the output. */
+    inheritFieldsFrom?: InheritFromSpec;
+    /** Strip workspace-internal entries from the output `dependencies` map. */
+    filterWorkspaceDepsFromOutput?: boolean;
+    /** Predicate identifying workspace-internal packages; required when filtering is enabled. */
+    isWorkspacePackage?: IsWorkspacePackagePredicate;
+    /** Override path for the `unpkg` field. */
+    unpkg?: string;
+    /** Override path for the `jsdelivr` field. */
+    jsdelivr?: string;
+    /** Bin declarations from the build config; drives `package.json#bin` synthesis. */
+    bins?: BinConfig[];
+    /** Allowlist for `package.json#files`; emitted verbatim when non-empty. */
+    files?: string[];
+}
+/**
+ * Composes the published `package.json` from the source manifest, the bundle-phase
+ * outputs, and caller-supplied options.
+ *
+ * Pipeline order is: filter workspace deps → apply inherited fields → assemble
+ * the new manifest with `sideEffects: false`, the regenerated `exports` map, and
+ * resolved `main` / `module` / `types` pointers; CDN fields are appended only
+ * when a UMD or IIFE bundle was emitted; the `bin` field is synthesized from
+ * the supplied bin declarations using deterministic naming rules; the `files`
+ * allowlist is forwarded verbatim when supplied.
+ *
+ * Root-pointers (`main`, `module`, `types`) are removed entirely when the
+ * library has no root entry, so consumers cannot resolve a non-existent default.
+ *
+ * @param srcPkg - Source `package.json` parsed from the project root.
+ * @param ctx - Resolved build context (used for the entry-point discovery shape).
+ * @param formatOutputs - Aggregated outputs collected by the bundle phase.
+ * @param opts - Inheritance / filter / CDN-override / bin / files toggles.
+ * @returns The fully assembled `PackageJson` ready to be written to the dist root.
+ *
+ * @example Synthesizing the dist package.json for a library with workspace inlining
+ * ```typescript
+ * const distPkg = synthesizePackageJson(srcPkg, ctx, formatOutputs, {
+ *   inheritFieldsFrom: { from: '/abs/repo/package.json', fields: ['repository', 'bugs'] },
+ *   filterWorkspaceDepsFromOutput: true,
+ *   isWorkspacePackage: (n) => n.startsWith('@hyperfrontend/'),
+ *   bins: [{ name: 'hf-build', format: ['cjs'] }],
+ *   files: ['_dependencies/', 'bin/', 'index.*'],
+ * })
+ * ```
+ */
+export declare const synthesizePackageJson: (srcPkg: PackageJson, ctx: BuildContext, formatOutputs: FormatOutputs, opts?: SynthesizePackageJsonOptions) => PackageJson;
+//# sourceMappingURL=synthesize.d.ts.map

package/package/json/synthesize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"synthesize.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/package/json/synthesize.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAET,YAAY,EACZ,aAAa,EACb,eAAe,EACf,2BAA2B,EAC3B,WAAW,EACZ,MAAM,cAAc,CAAA;AAQrB;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C,2EAA2E;IAC3E,iBAAiB,CAAC,EAAE,eAAe,CAAA;IACnC,2EAA2E;IAC3E,6BAA6B,CAAC,EAAE,OAAO,CAAA;IACvC,6FAA6F;IAC7F,kBAAkB,CAAC,EAAE,2BAA2B,CAAA;IAChD,2CAA2C;IAC3C,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,8CAA8C;IAC9C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,mFAAmF;IACnF,IAAI,CAAC,EAAE,SAAS,EAAE,CAAA;IAClB,2EAA2E;IAC3E,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;CACjB;AAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,qBAAqB,GAChC,QAAQ,WAAW,EACnB,KAAK,YAAY,EACjB,eAAe,aAAa,EAC5B,OAAO,4BAA4B,KAClC,WA8CF,CAAA"}

package/package/json/write.d.ts

@@ -0,0 +1,18 @@
+import type { PackageJson } from '../../models';
+/**
+ * Writes the synthesized `package.json` to the build output directory.
+ *
+ * The file is emitted with two-space indentation (project-scope's default) and
+ * a trailing newline so the published artifact diffs cleanly against
+ * formatter-managed source files.
+ *
+ * @param outputPath - Absolute path to the output directory (the dist root).
+ * @param packageJson - Fully assembled `PackageJson` to serialize.
+ *
+ * @example Writing the dist package.json
+ * ```typescript
+ * writeOutputPackageJson(ctx.outputPath, distPkg)
+ * ```
+ */
+export declare const writeOutputPackageJson: (outputPath: string, packageJson: PackageJson) => void;
+//# sourceMappingURL=write.d.ts.map

package/package/json/write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/package/json/write.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AAG/C;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,sBAAsB,GAAI,YAAY,MAAM,EAAE,aAAa,WAAW,KAAG,IAErF,CAAA"}

package/package/licenses/collect.d.ts

@@ -0,0 +1,25 @@
+import type { ThirdPartyLicenseEntry } from './types';
+/**
+ * Collects license information for every external dependency of the project
+ * being built.
+ *
+ * The dependency list is supplied by the caller (typically the resolved external
+ * list from the bundle phase, with workspace-internal entries already removed).
+ * For each dependency, the function locates the installed package under
+ * `<workspaceRoot>/node_modules`, parses its `package.json`, scans for a LICENSE
+ * file, and attempts to derive a canonical license URL from the upstream
+ * repository field. Missing dependencies are logged at warn level and dropped
+ * from the result.
+ *
+ * @param workspaceRoot - Absolute path to the workspace root containing
+ * `node_modules`.
+ * @param externals - List of external (non-workspace) dependency names to inspect.
+ * @returns Sorted list of license entries, one per resolvable dependency.
+ *
+ * @example Collecting licenses for a built library's bundle phase externals
+ * ```typescript
+ * const entries = collectThirdPartyLicenses('/abs/repo', ['rollup', 'typescript'])
+ * ```
+ */
+export declare const collectThirdPartyLicenses: (workspaceRoot: string, externals: string[]) => ThirdPartyLicenseEntry[];
+//# sourceMappingURL=collect.d.ts.map

package/package/licenses/collect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/package/licenses/collect.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAsDrD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,yBAAyB,GAAI,eAAe,MAAM,EAAE,WAAW,MAAM,EAAE,KAAG,sBAAsB,EAQ5G,CAAA"}

package/package/licenses/generate-content.d.ts

@@ -0,0 +1,20 @@
+import type { ThirdPartyLicenseEntry } from './types';
+/**
+ * Renders the markdown body for `THIRD_PARTY_LICENSES.md` from a collected list
+ * of license entries.
+ *
+ * The output is a top-level heading followed by a two-column table mapping each
+ * dependency to a markdown link pointing at the upstream license file (or the
+ * raw license type when no URL is available). The body always ends with a
+ * trailing newline.
+ *
+ * @param entries - License entries produced by {@link collectThirdPartyLicenses}.
+ * @returns Markdown content suitable for writing to disk.
+ *
+ * @example Generating the markdown body from a license collection
+ * ```typescript
+ * const md = generateThirdPartyLicensesContent(entries)
+ * ```
+ */
+export declare const generateThirdPartyLicensesContent: (entries: ThirdPartyLicenseEntry[]) => string;
+//# sourceMappingURL=generate-content.d.ts.map

package/package/licenses/generate-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-content.d.ts","sourceRoot":"","sources":["../../../../../../../../libs/builder/src/package/licenses/generate-content.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,SAAS,CAAA;AAErD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,iCAAiC,GAAI,SAAS,sBAAsB,EAAE,KAAG,MAYrF,CAAA"}