@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,80 +0,0 @@
-/**
- * Project-specific patch queue policy evaluation.
- *
- * The policy is opt-in via `fireforge.json#patchPolicy`. Callers feed this
- * module either the current manifest (`verify`, `lint --per-patch`) or a
- * projected manifest assembled before a mutation commits (`export`,
- * `patch reorder`, etc.).
- */
-import type { PatchesManifest, PatchMetadata } from '../types/commands/index.js';
-import type { FireForgeConfig, PatchPolicyConfig, PatchPolicyRange } from '../types/config.js';
-/** Stable issue codes returned by patch policy evaluation. */
-export type PatchPolicyIssueCode = 'filename-pattern' | 'filename-captures' | 'filename-metadata-mismatch' | 'order-collision' | 'category-range' | 'reserved-range' | 'reserved-documentation' | 'reserved-files' | 'description-required' | 'numeric-gap' | 'upstream-allowlist' | 'add-only' | 'scope' | 'reserved-document-missing';
-/** A single patch policy validation finding. */
-export interface PatchPolicyIssue {
-    code: PatchPolicyIssueCode;
-    filename: string;
-    message: string;
-    severity: 'error' | 'warning';
-}
-/** Input for enforcing policy during mutating commands. */
-export interface PatchPolicyEnforcementInput {
-    config: FireForgeConfig;
-    manifest: PatchesManifest;
-    command: string;
-    forceUnsafe?: boolean;
-    /**
-     * Per-issue-code remediation lines appended to matching details, so a
-     * refusal can name the exact flag or command that fixes it on the
-     * command it was raised from (e.g. `--description` on
-     * `patch move-files --create`).
-     */
-    hints?: Partial<Record<PatchPolicyIssueCode, string>>;
-    /**
-     * Patch filenames whose findings this mutation answers for. When set, only
-     * issues attributed to these rows are enforced: queue-level findings
-     * (order collisions, numeric gaps) and other patches' findings are left to
-     * `verify` and `lint --per-patch`. For mutations that change only the
-     * scoped rows' contents (`re-export`), so one patch's stale row cannot fail
-     * an unrelated patch refreshed in the same call.
-     */
-    scope?: readonly string[];
-}
-/** Returns valid categories for prompts and CLI validation under the config. */
-export declare function getPatchPolicyCategories(config: FireForgeConfig): string[];
-/** Checks whether a category is accepted by the built-in defaults or the policy ranges. */
-export declare function isCategoryAllowedByConfig(config: FireForgeConfig, category: string): boolean;
-/**
- * Human-readable label for a category's configured ranges, e.g. `300-399`.
- * Exported for the forward-import hint, which must render the
- * range it found no legal ordinal in.
- */
-export declare function categoryRangeLabel(ranges: readonly PatchPolicyRange[], category: string): string;
-/**
- * Returns the configured range that contains `order` for `category`, or
- * null when no such range exists. Exported for the forward-import hint,
- * which suppresses ordinal suggestions the reorder policy
- * would refuse.
- */
-export declare function categoryRangeForOrder(cfg: PatchPolicyConfig, category: string, order: number): PatchPolicyRange | null;
-/** Evaluates an entire patch manifest against the configured policy. */
-export declare function evaluatePatchPolicy(config: Pick<FireForgeConfig, 'patchPolicy'>, manifest: PatchesManifest): PatchPolicyIssue[];
-/**
- * Builds a sorted manifest snapshot from projected patch metadata. Retired
- * slots of `current` carry over unless a projected patch fills them, so a
- * projection judges gaps the way the written manifest will.
- */
-export declare function buildProjectedManifest(current: PatchesManifest | null, patches: PatchMetadata[]): PatchesManifest;
-/** Applies a filename/order rename projection to a manifest without mutating it. */
-export declare function applyRenameMapToManifest(manifest: PatchesManifest, renameMap: ReadonlyMap<string, {
-    newFilename: string;
-    newOrder: number;
-}>): PatchesManifest;
-/** Enforces patch policy according to the configured mutation mode. */
-export declare function enforcePatchPolicy(input: PatchPolicyEnforcementInput): void;
-/**
- * Allocates the next available order inside the configured ranges for a
- * category. Orders in `reserved` (`patch reserve`) are skipped: they are
- * held for their owner's export.
- */
-export declare function allocatePolicyOrder(config: FireForgeConfig, patches: readonly PatchMetadata[], category: string, reserved?: ReadonlySet<number>): number | null;

package/dist/src/core/patch-policy.js

@@ -1,394 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Project-specific patch queue policy evaluation.
- *
- * The policy is opt-in via `fireforge.json#patchPolicy`. Callers feed this
- * module either the current manifest (`verify`, `lint --per-patch`) or a
- * projected manifest assembled before a mutation commits (`export`,
- * `patch reorder`, etc.).
- */
-import { InvalidArgumentError } from '../errors/base.js';
-import { warn } from '../utils/logger.js';
-import { PATCH_CATEGORIES } from '../utils/validation.js';
-import { rewriteStagedDependencyOwners } from './patch-manifest-io.js';
-import { formatOrderRange, formatPatchOrder } from './patch-parse.js';
-import { manifestWithRetiredSlots, reservedOrderSet, retiredOrderSet } from './patch-retired.js';
-/** Default patch filename contract used when a policy omits `filenamePattern`. */
-const DEFAULT_PATCH_POLICY_FILENAME_PATTERN = '^(?<order>\\d{3})-(?<category>[a-z][a-z0-9-]*)-(?<slug>[a-z0-9-]+)\\.patch$';
-function policy(config) {
-    return config.patchPolicy;
-}
-function mutationMode(config) {
-    return policy(config)?.mutationMode ?? 'error';
-}
-/** Returns valid categories for prompts and CLI validation under the config. */
-export function getPatchPolicyCategories(config) {
-    const cfg = policy(config);
-    if (!cfg)
-        return [...PATCH_CATEGORIES];
-    return Array.from(new Set(cfg.ranges.map((range) => range.category))).sort((a, b) => a.localeCompare(b));
-}
-/** Checks whether a category is accepted by the built-in defaults or the policy ranges. */
-export function isCategoryAllowedByConfig(config, category) {
-    if (!/^[a-z][a-z0-9-]*$/.test(category))
-        return false;
-    const cfg = policy(config);
-    if (!cfg)
-        return PATCH_CATEGORIES.includes(category);
-    return cfg.ranges.some((range) => range.category === category);
-}
-/**
- * Human-readable label for a category's configured ranges, e.g. `300-399`.
- * Exported for the forward-import hint, which must render the
- * range it found no legal ordinal in.
- */
-export function categoryRangeLabel(ranges, category) {
-    const matches = ranges.filter((range) => range.category === category);
-    if (matches.length === 0)
-        return '(no configured range)';
-    return matches.map(formatOrderRange).join(', ');
-}
-function reservedRangeForOrder(cfg, order) {
-    return cfg.reservedRanges?.find((range) => order >= range.from && order <= range.to) ?? null;
-}
-/**
- * Returns the configured range that contains `order` for `category`, or
- * null when no such range exists. Exported for the forward-import hint,
- * which suppresses ordinal suggestions the reorder policy
- * would refuse.
- */
-export function categoryRangeForOrder(cfg, category, order) {
-    return (cfg.ranges.find((range) => {
-        return range.category === category && order >= range.from && order <= range.to;
-    }) ?? null);
-}
-function anyRangeForOrder(cfg, order) {
-    return cfg.ranges.find((range) => order >= range.from && order <= range.to) ?? null;
-}
-function parseFilenameWithPolicy(cfg, patch, severity) {
-    if (cfg.filenamePattern === undefined) {
-        const defaultMatch = /^(?<order>\d{3})-(?<rest>[a-z0-9-]+)\.patch$/.exec(patch.filename);
-        const orderRaw = defaultMatch?.groups?.['order'];
-        const rest = defaultMatch?.groups?.['rest'];
-        if (!orderRaw || !rest) {
-            return [
-                {
-                    code: 'filename-pattern',
-                    filename: patch.filename,
-                    severity,
-                    message: `${patch.filename} does not match the default patchPolicy filename pattern ` +
-                        '(NNN-category-slug.patch).',
-                },
-            ];
-        }
-        const categories = Array.from(new Set(cfg.ranges.map((range) => range.category))).sort((a, b) => b.length - a.length);
-        const category = categories.find((candidate) => rest.startsWith(`${candidate}-`));
-        if (!category) {
-            return [
-                {
-                    code: 'filename-captures',
-                    filename: patch.filename,
-                    severity,
-                    message: `${patch.filename} does not encode one of the configured patchPolicy categories.`,
-                },
-            ];
-        }
-        const slug = rest.slice(category.length + 1);
-        if (!/^[a-z0-9-]+$/.test(slug)) {
-            return [
-                {
-                    code: 'filename-captures',
-                    filename: patch.filename,
-                    severity,
-                    message: `${patch.filename} does not encode a lowercase slug after category "${category}".`,
-                },
-            ];
-        }
-        return { order: Number.parseInt(orderRaw, 10), category };
-    }
-    const pattern = new RegExp(cfg.filenamePattern ?? DEFAULT_PATCH_POLICY_FILENAME_PATTERN);
-    const match = pattern.exec(patch.filename);
-    if (!match) {
-        return [
-            {
-                code: 'filename-pattern',
-                filename: patch.filename,
-                severity,
-                message: `${patch.filename} does not match patchPolicy.filenamePattern ` +
-                    `(${cfg.filenamePattern ?? DEFAULT_PATCH_POLICY_FILENAME_PATTERN}).`,
-            },
-        ];
-    }
-    const groups = match.groups;
-    const orderRaw = groups?.['order'];
-    const category = groups?.['category'];
-    const slug = groups?.['slug'];
-    if (!orderRaw || !category || slug === undefined) {
-        return [
-            {
-                code: 'filename-captures',
-                filename: patch.filename,
-                severity,
-                message: 'patchPolicy.filenamePattern must expose named captures "order", "category", and "slug".',
-            },
-        ];
-    }
-    const order = Number.parseInt(orderRaw, 10);
-    if (!Number.isInteger(order)) {
-        return [
-            {
-                code: 'filename-captures',
-                filename: patch.filename,
-                severity,
-                message: `${patch.filename} has a non-numeric order capture "${orderRaw}".`,
-            },
-        ];
-    }
-    return { order, category };
-}
-function evaluatePatchMetadata(cfg, patch, severity) {
-    const issues = [];
-    const parsed = parseFilenameWithPolicy(cfg, patch, severity);
-    if (Array.isArray(parsed)) {
-        return parsed;
-    }
-    if (parsed.order !== patch.order || parsed.category !== patch.category) {
-        issues.push({
-            code: 'filename-metadata-mismatch',
-            filename: patch.filename,
-            severity,
-            message: `${patch.filename} encodes order/category ${parsed.order}/${parsed.category}, ` +
-                `but patches.json records ${patch.order}/${patch.category}.`,
-        });
-    }
-    if (cfg.requireDescription === true && patch.description.trim() === '') {
-        issues.push({
-            code: 'description-required',
-            filename: patch.filename,
-            severity,
-            message: `${patch.filename} has an empty description, but patchPolicy.requireDescription is true.`,
-        });
-    }
-    const reserved = reservedRangeForOrder(cfg, patch.order);
-    if (reserved) {
-        const allowed = reserved.allowed.find((entry) => entry.filename === patch.filename);
-        if (!allowed) {
-            issues.push({
-                code: 'reserved-range',
-                filename: patch.filename,
-                severity,
-                message: `${patch.filename} is in reserved range ${formatOrderRange(reserved)}. ` +
-                    'Reserved ranges require an exact patchPolicy.reservedRanges[].allowed filename exception.',
-            });
-            return issues;
-        }
-        if (!allowed.adr && !allowed.documentation) {
-            issues.push({
-                code: 'reserved-documentation',
-                filename: patch.filename,
-                severity,
-                message: `${patch.filename} is allowlisted for reserved range ${formatOrderRange(reserved)}, ` +
-                    'but the allowlist entry must include either "adr" or "documentation".',
-            });
-        }
-        if (allowed.files !== undefined) {
-            const allowedFiles = new Set(allowed.files);
-            const extraFiles = patch.filesAffected.filter((file) => !allowedFiles.has(file));
-            if (extraFiles.length > 0) {
-                issues.push({
-                    code: 'reserved-files',
-                    filename: patch.filename,
-                    severity,
-                    message: `${patch.filename} is allowlisted for reserved range ${formatOrderRange(reserved)}, ` +
-                        `but touches file(s) outside its reserved allowlist: ${extraFiles.join(', ')}.`,
-                });
-            }
-        }
-        return issues;
-    }
-    const matchingRange = categoryRangeForOrder(cfg, patch.category, patch.order);
-    if (!matchingRange) {
-        const owner = anyRangeForOrder(cfg, patch.order);
-        const expected = categoryRangeLabel(cfg.ranges, patch.category);
-        const actual = owner !== null
-            ? `${formatPatchOrder(patch.order)} is configured for ${owner.category} (${formatOrderRange(owner)})`
-            : `${formatPatchOrder(patch.order)} is outside all configured ranges`;
-        issues.push({
-            code: 'category-range',
-            filename: patch.filename,
-            severity,
-            message: `${patch.category} patches must use ${expected}; ${actual}. ` +
-                `Choose a ${patch.category} order in ${expected} or configure an explicit reserved-range exception.`,
-        });
-    }
-    return issues;
-}
-function evaluateGaps(cfg, patches, severity, retiredOrders = new Set()) {
-    if (cfg.allowGaps !== false)
-        return [];
-    const issues = [];
-    for (const range of cfg.ranges) {
-        const occupied = patches
-            .filter((patch) => {
-            return (patch.category === range.category &&
-                patch.order >= range.from &&
-                patch.order <= range.to &&
-                reservedRangeForOrder(cfg, patch.order) === null);
-        })
-            .map((patch) => patch.order)
-            .sort((a, b) => a - b);
-        if (occupied.length <= 1)
-            continue;
-        const occupiedSet = new Set(occupied);
-        const first = occupied[0];
-        const last = occupied[occupied.length - 1];
-        const missing = [];
-        for (let order = first; order <= last; order++) {
-            // A retired slot (`patch retire`) or a reservation (`patch reserve`)
-            // is an occupied order with no patch behind it, so it is not a gap.
-            if (!occupiedSet.has(order) &&
-                !retiredOrders.has(order) &&
-                reservedRangeForOrder(cfg, order) === null) {
-                missing.push(order);
-            }
-        }
-        if (missing.length > 0) {
-            issues.push({
-                code: 'numeric-gap',
-                filename: `${range.category}:${formatOrderRange(range)}`,
-                severity,
-                message: `${range.category} range ${formatOrderRange(range)} has numeric gap(s): ` +
-                    missing.map((order) => formatPatchOrder(order)).join(', ') +
-                    '. patchPolicy.allowGaps is false.',
-            });
-        }
-    }
-    return issues;
-}
-function evaluateOrderCollisions(patches, severity) {
-    const byOrder = new Map();
-    for (const patch of patches) {
-        const matches = byOrder.get(patch.order) ?? [];
-        matches.push(patch);
-        byOrder.set(patch.order, matches);
-    }
-    const issues = [];
-    for (const [order, matches] of [...byOrder.entries()].sort((a, b) => a[0] - b[0])) {
-        if (matches.length <= 1)
-            continue;
-        const filenames = matches.map((patch) => patch.filename).sort((a, b) => a.localeCompare(b));
-        issues.push({
-            code: 'order-collision',
-            filename: formatPatchOrder(order),
-            severity,
-            message: `patchPolicy requires unique numeric orders; order ${formatPatchOrder(order)} ` +
-                `is used by: ${filenames.join(', ')}.`,
-        });
-    }
-    return issues;
-}
-/** Evaluates an entire patch manifest against the configured policy. */
-export function evaluatePatchPolicy(config, manifest) {
-    const cfg = policy(config);
-    if (!cfg)
-        return [];
-    const severity = mutationMode(config) === 'warn' ? 'warning' : 'error';
-    const issues = manifest.patches.flatMap((patch) => evaluatePatchMetadata(cfg, patch, severity));
-    issues.push(...evaluateOrderCollisions(manifest.patches, severity));
-    // Retired and reserved slots are both spent orders with no patch behind
-    // them: neither is a gap.
-    const placeholders = new Set([...retiredOrderSet(manifest), ...reservedOrderSet(manifest)]);
-    issues.push(...evaluateGaps(cfg, manifest.patches, severity, placeholders));
-    return issues;
-}
-/**
- * Builds a sorted manifest snapshot from projected patch metadata. Retired
- * slots of `current` carry over unless a projected patch fills them, so a
- * projection judges gaps the way the written manifest will.
- */
-export function buildProjectedManifest(current, patches) {
-    const next = patches
-        .map((patch) => ({ ...patch, filesAffected: [...patch.filesAffected] }))
-        .sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
-    return manifestWithRetiredSlots(current, next);
-}
-/** Applies a filename/order rename projection to a manifest without mutating it. */
-export function applyRenameMapToManifest(manifest, renameMap) {
-    const ownerLookup = (oldFilename) => renameMap.get(oldFilename)?.newFilename;
-    return buildProjectedManifest(manifest, manifest.patches.map((patch) => {
-        // Staged-dependency owners reference other patches' filenames, so the
-        // projection rewrites them on every row to mirror what
-        // renumberPatchesInManifest persists.
-        const withOwners = rewriteStagedDependencyOwners(patch, ownerLookup);
-        const rename = renameMap.get(patch.filename);
-        if (!rename)
-            return withOwners;
-        return {
-            ...withOwners,
-            filename: rename.newFilename,
-            order: rename.newOrder,
-        };
-    }));
-}
-/** Enforces patch policy according to the configured mutation mode. */
-export function enforcePatchPolicy(input) {
-    if (policy(input.config) === undefined)
-        return;
-    const scope = input.scope === undefined ? undefined : new Set(input.scope);
-    const issues = evaluatePatchPolicy(input.config, input.manifest).filter((issue) => scope === undefined || scope.has(issue.filename));
-    if (issues.length === 0)
-        return;
-    const mode = mutationMode(input.config);
-    const details = issues.map((issue) => {
-        const hint = input.hints?.[issue.code];
-        return `  [${issue.code}] ${issue.message}${hint ? `\n      → ${hint}` : ''}`;
-    });
-    if (mode === 'warn') {
-        warn(`${input.command}: patch policy warning(s):`);
-        for (const detail of details)
-            warn(detail);
-        return;
-    }
-    if (mode === 'force' && input.forceUnsafe === true) {
-        warn(`${input.command}: bypassing patch policy violation(s) because --force-unsafe was provided:`);
-        for (const detail of details)
-            warn(detail);
-        return;
-    }
-    const suffix = mode === 'force'
-        ? '\n\nPass --force-unsafe only if you intentionally accept this policy violation.'
-        : '';
-    throw new InvalidArgumentError(`${input.command} would violate patchPolicy:\n${details.join('\n')}${suffix}`, mode === 'force' ? '--force-unsafe' : 'patchPolicy');
-}
-/**
- * Allocates the next available order inside the configured ranges for a
- * category. Orders in `reserved` (`patch reserve`) are skipped: they are
- * held for their owner's export.
- */
-export function allocatePolicyOrder(config, patches, category, reserved = new Set()) {
-    const cfg = policy(config);
-    if (!cfg)
-        return null;
-    const ranges = cfg.ranges
-        .filter((range) => range.category === category)
-        .sort((a, b) => a.from - b.from || a.to - b.to);
-    if (ranges.length === 0)
-        return null;
-    const occupied = new Set([...patches.map((patch) => patch.order), ...reserved]);
-    const highestInRanges = patches.reduce((highest, patch) => {
-        if (!ranges.some((range) => patch.order >= range.from && patch.order <= range.to)) {
-            return highest;
-        }
-        return highest === null ? patch.order : Math.max(highest, patch.order);
-    }, null);
-    const start = highestInRanges === null ? ranges[0]?.from : highestInRanges + 1;
-    if (start === undefined)
-        return null;
-    for (const range of ranges) {
-        for (let order = Math.max(start, range.from); order <= range.to; order++) {
-            if (!occupied.has(order))
-                return order;
-        }
-    }
-    return null;
-}

package/dist/src/core/patch-registration-refs.d.ts

@@ -1,41 +0,0 @@
-/**
- * Extracts furnace-shaped registration references from a patch body.
- *
- * `export-all --exclude-furnace` can land a patch that registers a furnace
- * component (via edits to `toolkit/content/customElements.js`,
- * `toolkit/content/jar.mn`, or `toolkit/locales/jar.mn`) without including
- * the component's source files, and `fireforge verify` then reports "Verify
- * clean" for the broken queue. This module provides a pattern-scoped scan so
- * `verify` can cross-check registrations against available file bodies.
- *
- * The scan is narrow on purpose: it only matches component-shaped
- * references (widget tag names, locale fluent names). Unrelated jar.mn or
- * customElements.js edits pass through without spurious warnings.
- */
-/**
- * A referenced engine path extracted from a registration hunk, together
- * with where it came from. The `source` field lets `verify` point
- * operators at the specific consequence file whose hunk introduced the
- * reference.
- */
-export interface PatchRegistrationReference {
-    /** Engine-relative path that the registration hunk adds a reference to. */
-    targetPath: string;
-    /** The registration file that contained the added hunk. */
-    source: string;
-    /** Raw hunk line that produced the reference, for diagnostic context. */
-    lineText: string;
-}
-/**
- * Walks a unified-diff patch body and returns the set of
- * component-shaped engine paths that the patch adds a registration for.
- *
- * Returns the empty array when no registration hunks are present, or
- * when the registration hunks do not mention any component-shaped
- * paths. That leaves the scan silent on the vast majority of patches
- * (branding tweaks, behavioural fixes, module additions) so it only
- * fires when a furnace-managed component is being newly registered.
- *
- * @param patchBody - Full unified-diff body of the patch file.
- */
-export declare function collectPatchRegistrationReferences(patchBody: string): PatchRegistrationReference[];

package/dist/src/core/patch-registration-refs.js

@@ -1,107 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Extracts furnace-shaped registration references from a patch body.
- *
- * `export-all --exclude-furnace` can land a patch that registers a furnace
- * component (via edits to `toolkit/content/customElements.js`,
- * `toolkit/content/jar.mn`, or `toolkit/locales/jar.mn`) without including
- * the component's source files, and `fireforge verify` then reports "Verify
- * clean" for the broken queue. This module provides a pattern-scoped scan so
- * `verify` can cross-check registrations against available file bodies.
- *
- * The scan is narrow on purpose: it only matches component-shaped
- * references (widget tag names, locale fluent names). Unrelated jar.mn or
- * customElements.js edits pass through without spurious warnings.
- */
-import { WIDGETS_DIR } from './furnace-constants.js';
-import { parseDiffSections } from './patch-parse.js';
-/** Canonical file paths that registration-shaped diffs touch. */
-const REGISTRATION_FILE_PATHS = new Set([
-    'toolkit/content/customElements.js',
-    'toolkit/content/jar.mn',
-    'toolkit/locales/jar.mn',
-]);
-/**
- * Walks a unified-diff patch body and returns the set of
- * component-shaped engine paths that the patch adds a registration for.
- *
- * Returns the empty array when no registration hunks are present, or
- * when the registration hunks do not mention any component-shaped
- * paths. That leaves the scan silent on the vast majority of patches
- * (branding tweaks, behavioural fixes, module additions) so it only
- * fires when a furnace-managed component is being newly registered.
- *
- * @param patchBody - Full unified-diff body of the patch file.
- */
-export function collectPatchRegistrationReferences(patchBody) {
-    if (!patchBody)
-        return [];
-    const refs = [];
-    // Key the file state off the `b/` path because that names the target
-    // side and is stable against renames. Only real hunk adds count.
-    // parseDiffSections has already filtered out header/metadata lines.
-    for (const section of parseDiffSections(patchBody)) {
-        if (!REGISTRATION_FILE_PATHS.has(section.targetPath))
-            continue;
-        for (const hunk of section.hunks) {
-            for (const line of hunk.lines) {
-                if (!line.startsWith('+'))
-                    continue;
-                const added = line.slice(1);
-                const extracted = extractTargetPathsFromRegistrationLine(section.targetPath, added);
-                for (const target of extracted) {
-                    refs.push({ targetPath: target, source: section.targetPath, lineText: added });
-                }
-            }
-        }
-    }
-    return refs;
-}
-/**
- * Per-source extractor. Each registration file has a distinct syntactic
- * shape. We scope the match to that file so a jar.mn regex does not
- * accidentally match a customElements.js line.
- */
-function extractTargetPathsFromRegistrationLine(sourceFile, added) {
-    if (sourceFile === 'toolkit/content/jar.mn') {
-        // Example (added line, leading `+` already stripped):
-        //   `   content/global/elements/moz-qa-panel.mjs  (widgets/moz-qa-panel/moz-qa-panel.mjs)`
-        // The parenthesised second half is the repo-relative path Firefox's
-        // packaging system reads. Widget registrations always live under
-        // `widgets/<tag>/<file>`, and the enclosing tree is
-        // `toolkit/content/widgets/`. Reconstruct the engine-relative
-        // target path so callers can check it against patch bodies.
-        const widgetMatch = /\(\s*(widgets\/[^\s)]+)\s*\)/.exec(added);
-        if (widgetMatch?.[1]) {
-            return [`toolkit/content/${widgetMatch[1]}`];
-        }
-        return [];
-    }
-    if (sourceFile === 'toolkit/locales/jar.mn') {
-        // Example:
-        //   `  locale/@AB_CD@/toolkit/global/moz-qa-panel.ftl (%toolkit/global/moz-qa-panel.ftl)`
-        // The `%`-prefixed repo-relative reference points at
-        // `toolkit/locales/en-US/<rel>`, which is the canonical FTL path.
-        const localeMatch = /\(%\s*([^\s)]+\.ftl)\s*\)/.exec(added);
-        if (localeMatch?.[1]) {
-            return [`toolkit/locales/en-US/${localeMatch[1]}`];
-        }
-        return [];
-    }
-    if (sourceFile === 'toolkit/content/customElements.js') {
-        // Example:
-        //   `          ["moz-qa-panel", "chrome://global/content/elements/moz-qa-panel.mjs"],`
-        // The chrome URL maps back to
-        // `toolkit/content/widgets/<tag>/<tag>.mjs` by convention: the
-        // packager rewrites `chrome://global/content/elements/<file>` to the
-        // widget tree root. The tag name is the identifier we key off.
-        const elementMatch = /\[\s*"([a-z][a-z0-9-]*)"\s*,\s*"chrome:\/\/global\/content\/elements\/([a-zA-Z0-9_-]+)\.mjs"\s*\]/.exec(added);
-        if (elementMatch?.[1] && elementMatch[2]) {
-            const tag = elementMatch[1];
-            const fileStem = elementMatch[2];
-            return [`${WIDGETS_DIR}/${tag}/${fileStem}.mjs`];
-        }
-        return [];
-    }
-    return [];
-}

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

@@ -1,57 +0,0 @@
-/**
- * Retired order slots: the placeholders `patch retire` leaves in
- * `patches.json#retired` so a patch can leave the queue without opening a
- * numeric gap or renumbering its successors.
- *
- * A slot is not a patch. It has no `.patch` file and no row in `patches`,
- * so everything that applies, exports, lints or rebases the queue walks past
- * it without knowing it exists. The one reader is the
- * `patchPolicy.allowGaps: false` gap check, which counts a retired order as
- * occupied. A patch that later takes the same order fills the slot, and
- * {@link carryRetiredSlots} drops it on that write, so the manifest never
- * holds a slot and a patch at one order.
- *
- * Reserved slots (`patch reserve`) follow the same rules: a placeholder for
- * an order a session has claimed but not exported yet, counted as occupied
- * by the gap check and filled (and dropped) by the export that lands on it.
- */
-import type { PatchesManifest, PatchMetadata, PatchReservedSlot, PatchRetiredSlot } from '../types/commands/index.js';
-/**
- * The retired slots of `current` that no patch in `patches` occupies, or
- * undefined when none remain. Every manifest write that rebuilds the
- * `patches` list routes the slots through here, so a slot survives the
- * rewrite and a filled one does not.
- *
- * @param current - Manifest the slots come from (null or slot-free: none)
- * @param patches - The rows the written manifest will hold
- */
-export declare function carryRetiredSlots(current: Pick<PatchesManifest, 'retired'> | null | undefined, patches: readonly Pick<PatchMetadata, 'order'>[]): PatchRetiredSlot[] | undefined;
-/**
- * Reserved twin of {@link carryRetiredSlots}: the reservations of `current`
- * that no patch in `patches` has filled yet.
- *
- * @param current - Manifest the slots come from
- * @param patches - The rows the written manifest will hold
- */
-export declare function carryReservedSlots(current: Pick<PatchesManifest, 'reserved'> | null | undefined, patches: readonly Pick<PatchMetadata, 'order'>[]): PatchReservedSlot[] | undefined;
-/**
- * Builds a manifest from `patches` that keeps `current`'s unfilled retired
- * and reserved slots. Each key is omitted entirely when no slot remains, so
- * a queue that never retired or reserved anything writes the same JSON as
- * before.
- *
- * @param current - Manifest the slots come from
- * @param patches - The rows the written manifest will hold
- */
-export declare function manifestWithRetiredSlots(current: Pick<PatchesManifest, 'retired' | 'reserved'> | null | undefined, patches: PatchMetadata[]): PatchesManifest;
-/** The set of order numbers held by retired slots. */
-export declare function retiredOrderSet(manifest: Pick<PatchesManifest, 'retired'>): Set<number>;
-/** The set of order numbers held by reserved slots. */
-export declare function reservedOrderSet(manifest: Pick<PatchesManifest, 'reserved'>): Set<number>;
-/**
- * The reservation at `order`, if any.
- *
- * @param manifest - Manifest to search (null: none)
- * @param order - Order number
- */
-export declare function reservationAt(manifest: Pick<PatchesManifest, 'reserved'> | null | undefined, order: number): PatchReservedSlot | undefined;