@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/core/patch-manifest-query.d.ts

@@ -1,55 +0,0 @@
-/**
- * Query helpers: finding patches by file, integrity checks, version compat, stamping.
- */
-import type { PatchesManifest, PatchInfo, PatchMetadata } from '../types/commands/index.js';
-import type { FirefoxProduct } from '../types/config.js';
-/**
- * Gets all file paths claimed by patches other than the excluded one.
- * @param manifest - The patches manifest
- * @param excludeFilename - Filename to exclude from collection
- * @returns Set of file paths claimed by other patches
- */
-export declare function getClaimedFiles(manifest: PatchesManifest, excludeFilename: string): Set<string>;
-/**
- * Checks Firefox source version compatibility.
- * @param patchVersion - Version the patch was created for
- * @param currentVersion - Current project version
- * @returns Warning message if versions differ, null if compatible
- */
-export declare function checkVersionCompatibility(patchVersion: string, currentVersion: string): string | null;
-/**
- * Finds all patches that affect a specific file.
- * @param patchesDir - Path to the patches directory
- * @param filePath - File path to search for
- * @returns Patches affecting the file, sorted by order
- */
-export declare function findPatchesAffectingFile(patchesDir: string, filePath: string): Promise<Array<{
-    patch: PatchInfo;
-    metadata: PatchMetadata;
-}>>;
-/**
- * Validates that all patches can be applied successfully.
- * Detects modification patches that reference files not in the source.
- * @param patchesDir - Path to the patches directory
- * @param engineDir - Path to the engine directory
- * @returns Array of validation issues with details
- */
-export declare function validatePatchIntegrity(patchesDir: string, engineDir: string): Promise<Array<{
-    filename: string;
-    message: string;
-    targetFile: string | null;
-}>>;
-/**
- * Stamps multiple patches with a new source version in a single
- * manifest read-modify-write cycle.
- *
- * Acquires the shared patch-directory lock for the read-modify-write, so a
- * concurrent export/reorder/metadata update cannot interleave with the stamp.
- * The lock is not reentrant: callers must not invoke this while already
- * holding {@link withPatchDirectoryLock} on the same patches directory.
- *
- * @param patchesDir - Path to the patches directory
- * @param filenames - Patch filenames to update
- * @param newVersion - Version string to set (e.g. "140.9.0esr")
- */
-export declare function stampPatchVersions(patchesDir: string, filenames: string[], newVersion: string, newProduct?: FirefoxProduct): Promise<void>;

package/dist/src/core/patch-manifest-query.js

@@ -1,139 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Query helpers: finding patches by file, integrity checks, version compat, stamping.
- */
-import { readText } from '../utils/fs.js';
-import { listTrackedInHead } from './git-file-ops.js';
-import { discoverPatches, getAllTargetFilesFromPatch } from './patch-files.js';
-import { withPatchDirectoryLock } from './patch-lock.js';
-import { loadPatchesManifest, mutatePatchRowsInManifest } from './patch-manifest-io.js';
-import { isNewFileInPatch } from './patch-parse.js';
-/**
- * Gets all file paths claimed by patches other than the excluded one.
- * @param manifest - The patches manifest
- * @param excludeFilename - Filename to exclude from collection
- * @returns Set of file paths claimed by other patches
- */
-export function getClaimedFiles(manifest, excludeFilename) {
-    const claimed = new Set();
-    for (const patch of manifest.patches) {
-        if (patch.filename === excludeFilename)
-            continue;
-        for (const file of patch.filesAffected) {
-            claimed.add(file);
-        }
-    }
-    return claimed;
-}
-/**
- * Checks Firefox source version compatibility.
- * @param patchVersion - Version the patch was created for
- * @param currentVersion - Current project version
- * @returns Warning message if versions differ, null if compatible
- */
-export function checkVersionCompatibility(patchVersion, currentVersion) {
-    if (patchVersion === currentVersion) {
-        return null;
-    }
-    // Extract major version numbers
-    const patchMajor = parseInt(patchVersion.split('.')[0] ?? '0', 10);
-    const currentMajor = parseInt(currentVersion.split('.')[0] ?? '0', 10);
-    if (patchMajor !== currentMajor) {
-        return (`Patch was created for Firefox ${patchVersion}, ` +
-            `but current version is ${currentVersion}. ` +
-            `Major version mismatch may cause conflicts.`);
-    }
-    return (`Patch was created for Firefox ${patchVersion}, ` + `current version is ${currentVersion}.`);
-}
-/**
- * Finds all patches that affect a specific file.
- * @param patchesDir - Path to the patches directory
- * @param filePath - File path to search for
- * @returns Patches affecting the file, sorted by order
- */
-export async function findPatchesAffectingFile(patchesDir, filePath) {
-    const manifest = await loadPatchesManifest(patchesDir);
-    if (!manifest)
-        return [];
-    const patches = await discoverPatches(patchesDir);
-    const results = [];
-    for (const metadata of manifest.patches) {
-        if (metadata.filesAffected.includes(filePath)) {
-            const patch = patches.find((p) => p.filename === metadata.filename);
-            if (patch) {
-                results.push({ patch, metadata });
-            }
-        }
-    }
-    // Sort by order
-    results.sort((a, b) => a.patch.order - b.patch.order);
-    return results;
-}
-/**
- * Validates that all patches can be applied successfully.
- * Detects modification patches that reference files not in the source.
- * @param patchesDir - Path to the patches directory
- * @param engineDir - Path to the engine directory
- * @returns Array of validation issues with details
- */
-export async function validatePatchIntegrity(patchesDir, engineDir) {
-    const issues = [];
-    const patches = await discoverPatches(patchesDir);
-    // Collect every modification target first, then resolve HEAD existence in
-    // one batched ls-tree pass (chunked for ARG_MAX). The per-file
-    // fileExistsInHead fan-out spawned one git process per (patch × target) on
-    // every import: a 56-file branding patch alone cost ~56 spawns before a
-    // single patch was applied.
-    const modificationTargets = [];
-    for (const patch of patches) {
-        // Check all files in the patch (supports multi-file patches)
-        const patchContent = await readText(patch.path);
-        const targetFiles = await getAllTargetFilesFromPatch(patch.path);
-        for (const targetFile of targetFiles) {
-            // Skip new-file sections. They don't need to exist in HEAD
-            if (isNewFileInPatch(patchContent, targetFile))
-                continue;
-            modificationTargets.push({ filename: patch.filename, targetFile });
-        }
-    }
-    const tracked = await listTrackedInHead(engineDir, modificationTargets.map((t) => t.targetFile));
-    for (const { filename, targetFile } of modificationTargets) {
-        if (!tracked.has(targetFile)) {
-            issues.push({
-                filename,
-                message: `Modification patch for file that doesn't exist in source. Re-export with: fireforge export ${targetFile}`,
-                targetFile,
-            });
-        }
-    }
-    return issues;
-}
-/**
- * Stamps multiple patches with a new source version in a single
- * manifest read-modify-write cycle.
- *
- * Acquires the shared patch-directory lock for the read-modify-write, so a
- * concurrent export/reorder/metadata update cannot interleave with the stamp.
- * The lock is not reentrant: callers must not invoke this while already
- * holding {@link withPatchDirectoryLock} on the same patches directory.
- *
- * @param patchesDir - Path to the patches directory
- * @param filenames - Patch filenames to update
- * @param newVersion - Version string to set (e.g. "140.9.0esr")
- */
-export async function stampPatchVersions(patchesDir, filenames, newVersion, newProduct) {
-    await withPatchDirectoryLock(patchesDir, () => mutatePatchRowsInManifest(patchesDir, filenames, (patch, rawPatch) => {
-        if (patch.sourceEsrVersion !== newVersion ||
-            rawPatch['sourceVersion'] !== newVersion ||
-            (newProduct !== undefined && rawPatch['sourceProduct'] !== newProduct)) {
-            return {
-                set: {
-                    sourceEsrVersion: newVersion,
-                    sourceVersion: newVersion,
-                    ...(newProduct !== undefined ? { sourceProduct: newProduct } : {}),
-                },
-            };
-        }
-        return null;
-    }));
-}

package/dist/src/core/patch-manifest-resolve.d.ts

@@ -1,21 +0,0 @@
-import type { PatchMetadata } from '../types/commands/index.js';
-/**
- * Resolves a patch identifier to its manifest entry. Accepts:
- *
- *   1. An ordinal number (e.g. `2`), matching `PatchMetadata.order`.
- *   2. A full filename with `.patch` suffix (e.g. `002-ui-foo.patch`),
- *      matching `PatchMetadata.filename`.
- *   3. A filename without the `.patch` suffix. The command appends it
- *      before matching (e.g. `002-ui-foo`).
- *   4. The manifest `name` field (e.g. `furnace-token-override`), the short
- *      logical handle the export workflow stamps onto the patch and the
- *      natural identifier an operator keeps in their notes. The CLI help
- *      says `<name>`, so rejecting it forces the operator to copy the full
- *      filename out of `patches.json` before every queue mutation.
- *
- * Resolution order is strict: numeric ordinals first, then filename lookup
- * (with and without the `.patch` suffix), then name-field lookup. The
- * filename lookup beats the name lookup when the two collide, so scripts
- * that pass filenames keep working.
- */
-export declare function resolvePatchIdentifier(identifier: string, patches: PatchMetadata[]): PatchMetadata | null;

package/dist/src/core/patch-manifest-resolve.js

@@ -1,35 +0,0 @@
-/**
- * Resolves a patch identifier to its manifest entry. Accepts:
- *
- *   1. An ordinal number (e.g. `2`), matching `PatchMetadata.order`.
- *   2. A full filename with `.patch` suffix (e.g. `002-ui-foo.patch`),
- *      matching `PatchMetadata.filename`.
- *   3. A filename without the `.patch` suffix. The command appends it
- *      before matching (e.g. `002-ui-foo`).
- *   4. The manifest `name` field (e.g. `furnace-token-override`), the short
- *      logical handle the export workflow stamps onto the patch and the
- *      natural identifier an operator keeps in their notes. The CLI help
- *      says `<name>`, so rejecting it forces the operator to copy the full
- *      filename out of `patches.json` before every queue mutation.
- *
- * Resolution order is strict: numeric ordinals first, then filename lookup
- * (with and without the `.patch` suffix), then name-field lookup. The
- * filename lookup beats the name lookup when the two collide, so scripts
- * that pass filenames keep working.
- */
-export function resolvePatchIdentifier(identifier, patches) {
-    if (/^\d+$/.test(identifier)) {
-        const order = parseInt(identifier, 10);
-        return patches.find((p) => p.order === order) ?? null;
-    }
-    // Filename lookup: try the input as-is first (covers both the
-    // full `.patch` form and a bare name, because `endsWith` treats the
-    // bare form as a miss and falls through to the appended variant).
-    const normalized = identifier.endsWith('.patch') ? identifier : `${identifier}.patch`;
-    const byFilename = patches.find((p) => p.filename === normalized || p.filename === identifier);
-    if (byFilename)
-        return byFilename;
-    // Name-field lookup: the short logical handle stamped into the
-    // manifest at export time. See function docstring.
-    return patches.find((p) => p.name === identifier) ?? null;
-}

package/dist/src/core/patch-manifest-stage.d.ts

@@ -1,46 +0,0 @@
-/**
- * The manifest `patch stage` writes into the git index: HEAD's
- * `patches.json` with only the named patches' rows (and their retired and
- * reserved slots) taken from the working copy.
- *
- * Sessions sharing one checkout each touch their own rows of the shared
- * manifest. Staging the whole file commits every session's rows under one
- * message; staging hunks with `git apply --cached --unidiff-zero` lands a
- * kept insertion at its new-side line number once a dropped hunk above it
- * shifted the file, and committed invalid JSON. Merging rows from the
- * parsed manifests has neither failure: the result is built from structure,
- * then validated before anything is staged.
- */
-import type { PatchesManifest } from '../types/commands/index.js';
-/** What staging does to one named patch's row. */
-export type StagedRowChange = 'added' | 'updated' | 'removed' | 'unchanged';
-/** The staged manifest and the per-patch row changes it carries. */
-export interface StagedManifest {
-    manifest: PatchesManifest;
-    changes: Array<{
-        filename: string;
-        change: StagedRowChange;
-    }>;
-}
-/**
- * Merges the named rows of `working` into `head`.
- *
- * Rows: every unnamed row comes from HEAD; a named row comes from the
- * working copy, or leaves when the working copy no longer has it.
- * Retired slots: a slot whose `filename` is named follows the working
- * copy, the rest follow HEAD. Reserved slots follow HEAD. A slot whose
- * order a staged row now fills is dropped, as every manifest write does.
- *
- * @param head - HEAD's manifest, or null when HEAD has none
- * @param working - The working-copy manifest
- * @param filenames - Patch filenames whose rows to take from the working copy
- * @returns The validated manifest and the row changes
- * @throws Error when two rows would hold one order, or the merge does not
- *   validate
- */
-export declare function mergeStagedManifest(head: PatchesManifest | null, working: PatchesManifest, filenames: ReadonlySet<string>): StagedManifest;
-/**
- * Serializes a staged manifest exactly as the manifest writers do, so the
- * staged blob and a later full save of the same content are byte-identical.
- */
-export declare function serializeStagedManifest(manifest: PatchesManifest): string;

package/dist/src/core/patch-manifest-stage.js

@@ -1,96 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The manifest `patch stage` writes into the git index: HEAD's
- * `patches.json` with only the named patches' rows (and their retired and
- * reserved slots) taken from the working copy.
- *
- * Sessions sharing one checkout each touch their own rows of the shared
- * manifest. Staging the whole file commits every session's rows under one
- * message; staging hunks with `git apply --cached --unidiff-zero` lands a
- * kept insertion at its new-side line number once a dropped hunk above it
- * shifted the file, and committed invalid JSON. Merging rows from the
- * parsed manifests has neither failure: the result is built from structure,
- * then validated before anything is staged.
- */
-import { toError } from '../utils/errors.js';
-import { canonicalizeManifest } from './patch-manifest-key-order.js';
-import { validatePatchesManifest } from './patch-manifest-validate.js';
-import { carryReservedSlots, carryRetiredSlots } from './patch-retired.js';
-/**
- * Merges the named rows of `working` into `head`.
- *
- * Rows: every unnamed row comes from HEAD; a named row comes from the
- * working copy, or leaves when the working copy no longer has it.
- * Retired slots: a slot whose `filename` is named follows the working
- * copy, the rest follow HEAD. Reserved slots follow HEAD. A slot whose
- * order a staged row now fills is dropped, as every manifest write does.
- *
- * @param head - HEAD's manifest, or null when HEAD has none
- * @param working - The working-copy manifest
- * @param filenames - Patch filenames whose rows to take from the working copy
- * @returns The validated manifest and the row changes
- * @throws Error when two rows would hold one order, or the merge does not
- *   validate
- */
-export function mergeStagedManifest(head, working, filenames) {
-    const headRows = head?.patches ?? [];
-    const changes = [...filenames].sort().map((filename) => {
-        const before = headRows.find((row) => row.filename === filename);
-        const after = working.patches.find((row) => row.filename === filename);
-        const change = before === undefined
-            ? 'added'
-            : after === undefined
-                ? 'removed'
-                : JSON.stringify(canonicalRow(before)) === JSON.stringify(canonicalRow(after))
-                    ? 'unchanged'
-                    : 'updated';
-        return { filename, change };
-    });
-    const rows = [
-        ...headRows.filter((row) => !filenames.has(row.filename)),
-        ...working.patches.filter((row) => filenames.has(row.filename)),
-    ].sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
-    assertNoCollision(rows);
-    const retiredSource = [
-        ...(head?.retired ?? []).filter((slot) => !filenames.has(slot.filename)),
-        ...(working.retired ?? []).filter((slot) => filenames.has(slot.filename)),
-    ];
-    const retired = carryRetiredSlots({ retired: retiredSource }, rows);
-    const reserved = carryReservedSlots(head, rows);
-    const merged = {
-        version: 1,
-        patches: rows,
-        ...(retired !== undefined ? { retired } : {}),
-        ...(reserved !== undefined ? { reserved } : {}),
-    };
-    try {
-        validatePatchesManifest(JSON.parse(JSON.stringify(merged)));
-    }
-    catch (error) {
-        throw new Error(`the staged manifest would not validate: ${toError(error).message}`, {
-            cause: error,
-        });
-    }
-    return { manifest: canonicalizeManifest(merged), changes };
-}
-function canonicalRow(row) {
-    return canonicalizeManifest({ patches: [row] }).patches[0];
-}
-function assertNoCollision(rows) {
-    const seen = new Map();
-    for (const row of rows) {
-        const holder = seen.get(row.order);
-        if (holder !== undefined) {
-            throw new Error(`order ${String(row.order)} would be held by both ${holder} and ${row.filename}; ` +
-                'stage the patch that moved off that order as well');
-        }
-        seen.set(row.order, row.filename);
-    }
-}
-/**
- * Serializes a staged manifest exactly as the manifest writers do, so the
- * staged blob and a later full save of the same content are byte-identical.
- */
-export function serializeStagedManifest(manifest) {
-    return `${JSON.stringify(manifest, null, 2)}\n`;
-}

package/dist/src/core/patch-manifest-validate.d.ts

@@ -1,20 +0,0 @@
-/**
- * Schema validation for patches.json manifest data.
- */
-import type { PatchCategory, PatchesManifest } from '../types/commands/index.js';
-/**
- * Validates raw patches.json data and returns the typed manifest shape.
- *
- * @param data - Parsed patches.json content
- * @returns The validated manifest
- */
-export declare function validatePatchesManifest(data: unknown): PatchesManifest;
-/**
- * Infers patch metadata from a filename pattern.
- * @param filename - Patch filename (e.g. "001-ui-toolbar.patch")
- * @returns Inferred category and name
- */
-export declare function inferPatchMetadataFromFilename(filename: string): {
-    category: PatchCategory;
-    name: string;
-};

package/dist/src/core/patch-manifest-validate.js

@@ -1,240 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Schema validation for patches.json manifest data.
- */
-import { parseObject } from '../utils/parse.js';
-import { isArray, isObject, isValidFirefoxProduct, isValidFirefoxVersion, PATCH_CATEGORIES, } from '../utils/validation.js';
-import { parseLintIgnoreEntries } from './patch-lint-ignore.js';
-import { canonicalizePatchRow } from './patch-manifest-key-order.js';
-import { checkDocumentVersion, describeNewerDocument } from './state-file.js';
-function parseForwardImports(data, label) {
-    if (!isArray(data)) {
-        throw new Error(`${label} must be an array`);
-    }
-    return data.map((entry, index) => {
-        const rec = parseObject(entry, `${label}[${index}]`);
-        const dependency = {
-            file: rec.string('file'),
-            specifier: rec.string('specifier'),
-            creates: rec.string('creates'),
-        };
-        const owner = rec.optionalString('owner');
-        if (owner !== undefined)
-            dependency.owner = owner;
-        const reason = rec.optionalString('reason');
-        if (reason !== undefined)
-            dependency.reason = reason;
-        return dependency;
-    });
-}
-function parseRegistrations(data, label) {
-    if (!isArray(data)) {
-        throw new Error(`${label} must be an array`);
-    }
-    return data.map((entry, index) => {
-        const rec = parseObject(entry, `${label}[${index}]`);
-        const dependency = {
-            file: rec.string('file'),
-            line: rec.string('line'),
-            creates: rec.string('creates'),
-        };
-        const owner = rec.optionalString('owner');
-        if (owner !== undefined)
-            dependency.owner = owner;
-        const reason = rec.optionalString('reason');
-        if (reason !== undefined)
-            dependency.reason = reason;
-        return dependency;
-    });
-}
-function parseStagedDependencies(data, label) {
-    const rec = parseObject(data, label);
-    const rawForwardImports = rec.raw('forwardImports');
-    const rawRegistrations = rec.raw('registrations');
-    const staged = {};
-    if (rawForwardImports !== undefined) {
-        staged.forwardImports = parseForwardImports(rawForwardImports, `${label}.forwardImports`);
-    }
-    if (rawRegistrations !== undefined) {
-        staged.registrations = parseRegistrations(rawRegistrations, `${label}.registrations`);
-    }
-    return staged;
-}
-/**
- * Validates a single patch metadata entry from raw data.
- * @param data - Raw data to validate
- * @param index - Array index for error messages
- * @returns Validated PatchMetadata
- */
-function validatePatchMetadata(data, index) {
-    const rec = parseObject(data, `patches[${index}]`);
-    const filename = rec.string('filename');
-    const name = rec.string('name');
-    const description = rec.string('description');
-    const createdAt = rec.string('createdAt');
-    const sourceEsrVersion = rec.optionalString('sourceEsrVersion');
-    const sourceVersion = rec.optionalString('sourceVersion') ?? sourceEsrVersion;
-    if (sourceVersion === undefined) {
-        throw new Error(`patches[${index}] must include sourceVersion or legacy sourceEsrVersion`);
-    }
-    const sourceProductRaw = rec.optionalString('sourceProduct');
-    let sourceProduct;
-    if (sourceProductRaw !== undefined) {
-        if (!isValidFirefoxProduct(sourceProductRaw)) {
-            throw new Error(`patches[${index}].sourceProduct must be one of: firefox, firefox-esr, firefox-beta, firefox-devedition`);
-        }
-        sourceProduct = sourceProductRaw;
-    }
-    const order = rec.nonNegativeInteger('order');
-    const category = rec.validatedString('category', (value) => /^[a-z][a-z0-9-]*$/.test(value), 'a lowercase category identifier (letters, numbers, hyphens)');
-    if (!isValidFirefoxVersion(sourceVersion)) {
-        throw new Error(`patches[${index}].sourceVersion must be a valid Firefox version string`);
-    }
-    if (sourceEsrVersion !== undefined && !isValidFirefoxVersion(sourceEsrVersion)) {
-        throw new Error(`patches[${index}].sourceEsrVersion must be a valid Firefox version string`);
-    }
-    const filesAffected = rec.stringArray('filesAffected');
-    // Optional fields. These are easy to strip silently: an escape hatch
-    // that round-trips only through test fixtures mocking
-    // `loadPatchesManifest` looks fine while real operator edits to
-    // `patches.json` are dropped on every load, so a patch relying on
-    // `lintIgnore` to suppress a rule is quietly re-tripped the next time the
-    // manifest validates. Preserve both `lintIgnore` and `tier` here. Future
-    // optional fields follow the same template.
-    // Entries are bare check IDs or `{ rule, max, reason }` ceilings.
-    const rawLintIgnore = rec.raw('lintIgnore');
-    const lintIgnore = rawLintIgnore === undefined
-        ? undefined
-        : parseLintIgnoreEntries(rawLintIgnore, `patches[${index}].lintIgnore`);
-    const rawTier = rec.raw('tier');
-    let tier;
-    if (rawTier !== undefined) {
-        if (rawTier !== 'branding') {
-            throw new Error(`patches[${index}].tier must be "branding" when present (unknown tier values are rejected, not silently ignored).`);
-        }
-        tier = 'branding';
-    }
-    const result = {
-        filename,
-        order,
-        category,
-        name,
-        description,
-        createdAt,
-        sourceEsrVersion: sourceEsrVersion ?? sourceVersion,
-        sourceVersion,
-        filesAffected,
-    };
-    if (sourceProduct !== undefined)
-        result.sourceProduct = sourceProduct;
-    if (lintIgnore !== undefined)
-        result.lintIgnore = lintIgnore;
-    if (tier !== undefined)
-        result.tier = tier;
-    const rawStagedDependencies = rec.raw('stagedDependencies');
-    if (rawStagedDependencies !== undefined) {
-        result.stagedDependencies = parseStagedDependencies(rawStagedDependencies, `patches[${index}].stagedDependencies`);
-    }
-    return canonicalizePatchRow(result);
-}
-/**
- * Validates the `retired` placeholders `patch retire` leaves behind. Kept on
- * the manifest so every write that round-trips a loaded manifest carries
- * them; dropping them would silently reopen the gaps they were retired to
- * close.
- */
-function parseRetiredSlots(data) {
-    if (!isArray(data)) {
-        throw new Error('patches.json field "retired" must be an array');
-    }
-    return data.map((entry, index) => {
-        const rec = parseObject(entry, `retired[${index}]`);
-        const slot = {
-            order: rec.nonNegativeInteger('order'),
-            category: rec.validatedString('category', (value) => /^[a-z][a-z0-9-]*$/.test(value), 'a lowercase category identifier (letters, numbers, hyphens)'),
-            filename: rec.string('filename'),
-            retiredAt: rec.string('retiredAt'),
-        };
-        const reason = rec.optionalString('reason');
-        if (reason !== undefined)
-            slot.reason = reason;
-        return slot;
-    });
-}
-/**
- * Validates the `reserved` placeholders `patch reserve` writes. Same
- * survival rule as {@link parseRetiredSlots}: dropping one on a round trip
- * would reopen the gap a peer reserved the order to close.
- */
-function parseReservedSlots(data) {
-    if (!isArray(data)) {
-        throw new Error('patches.json field "reserved" must be an array');
-    }
-    return data.map((entry, index) => {
-        const rec = parseObject(entry, `reserved[${index}]`);
-        const slot = {
-            order: rec.nonNegativeInteger('order'),
-            category: rec.validatedString('category', (value) => /^[a-z][a-z0-9-]*$/.test(value), 'a lowercase category identifier (letters, numbers, hyphens)'),
-            owner: rec.validatedString('owner', (value) => value.trim() !== '', 'a non-empty label'),
-            reservedAt: rec.string('reservedAt'),
-        };
-        const reason = rec.optionalString('reason');
-        if (reason !== undefined)
-            slot.reason = reason;
-        return slot;
-    });
-}
-/** Manifest schema version this build writes and understands. */
-const PATCHES_MANIFEST_VERSION = 1;
-/**
- * Validates raw patches.json data and returns the typed manifest shape.
- *
- * @param data - Parsed patches.json content
- * @returns The validated manifest
- */
-export function validatePatchesManifest(data) {
-    if (!isObject(data)) {
-        throw new Error('patches.json must be a JSON object');
-    }
-    // A manifest from a newer FireForge is not corrupt. The bare "version must
-    // be 1" this replaced sent the operator looking for damage in a file that
-    // only needed a newer build to read it.
-    const version = checkDocumentVersion(data, 'version', PATCHES_MANIFEST_VERSION);
-    if (version.kind === 'newer') {
-        throw new Error(describeNewerDocument('patches manifest', version.found, PATCHES_MANIFEST_VERSION));
-    }
-    if (version.kind !== 'current') {
-        throw new Error(`patches.json version must be ${PATCHES_MANIFEST_VERSION}`);
-    }
-    if (!isArray(data['patches'])) {
-        throw new Error('patches.json field "patches" must be an array');
-    }
-    const manifest = {
-        version: 1,
-        patches: data['patches'].map((patch, index) => validatePatchMetadata(patch, index)),
-    };
-    if (data['retired'] !== undefined)
-        manifest.retired = parseRetiredSlots(data['retired']);
-    if (data['reserved'] !== undefined)
-        manifest.reserved = parseReservedSlots(data['reserved']);
-    return manifest;
-}
-/**
- * Infers patch metadata from a filename pattern.
- * @param filename - Patch filename (e.g. "001-ui-toolbar.patch")
- * @returns Inferred category and name
- */
-export function inferPatchMetadataFromFilename(filename) {
-    const categorizedMatch = /^(\d+)-([a-z]+)-(.+)\.patch$/.exec(filename);
-    if (categorizedMatch?.[2] && categorizedMatch[3]) {
-        const category = categorizedMatch[2];
-        if (PATCH_CATEGORIES.includes(category)) {
-            return { category, name: categorizedMatch[3] };
-        }
-    }
-    const legacyMatch = /^(\d+)-(.+)\.patch$/.exec(filename);
-    if (legacyMatch?.[2]) {
-        return { category: 'infra', name: legacyMatch[2] };
-    }
-    return { category: 'infra', name: filename.replace(/\.patch$/, '') };
-}

package/dist/src/core/patch-manifest.d.ts

@@ -1,12 +0,0 @@
-/**
- * Patches manifest: re-exports from focused sub-modules.
- *
- * Callers should continue to import from this module. The internal split
- * is an implementation detail.
- */
-export { type PatchManifestConsistencyIssue, rebuildPatchesManifest, recommendManifestRepair, validatePatchesManifestConsistency, } from './patch-manifest-consistency.js';
-export { type FilesAffectedRepair, repairPatchesFilesAffected, } from './patch-manifest-files-affected.js';
-export { addPatchToManifest, loadPatchesManifest, loadPatchesManifestForWrite, mutatePatchRowsInManifest, PATCHES_MANIFEST, type PatchRenameEntry, removePatchFileAndManifest, renumberPatchesInManifest, rewriteStagedDependencyOwners, savePatchesManifest, } from './patch-manifest-io.js';
-export { checkVersionCompatibility, findPatchesAffectingFile, getClaimedFiles, stampPatchVersions, validatePatchIntegrity, } from './patch-manifest-query.js';
-export { resolvePatchIdentifier } from './patch-manifest-resolve.js';
-export { validatePatchesManifest } from './patch-manifest-validate.js';