@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/export-placement-policy.d.ts

@@ -1,22 +0,0 @@
-/**
- * Policy-aware checks for export placement plans.
- */
-import type { PatchMetadata } from '../types/commands/index.js';
-import type { FireForgeConfig } from '../types/config.js';
-export interface PlacementPolicyPlan {
-    insertionOrder: number;
-    renameMap: ReadonlyMap<string, {
-        newFilename: string;
-        newOrder: number;
-    }>;
-}
-/**
- * Refuses positional placement plans whose renumber would touch a
- * `patchPolicy.reservedRanges` block, either by moving a patch into a
- * reserved range or by moving a patch that currently sits inside one.
- * Throws a single up-front error for the first reserved range hit (the
- * per-patch alternative surfaced one confusing finding per shifted
- * patch), suggesting the first free `--order` below the block when one
- * exists. Exact `--order` plans have an empty rename map and pass.
- */
-export declare function assertPlacementAvoidsReservedRanges(plan: PlacementPolicyPlan, manifestPatches: readonly PatchMetadata[], config: FireForgeConfig | undefined): void;

package/dist/src/commands/export-placement-policy.js

@@ -1,54 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Policy-aware checks for export placement plans.
- */
-import { formatOrderRange, formatPatchOrder } from '../core/patch-parse.js';
-import { InvalidArgumentError } from '../errors/base.js';
-function findReservedRange(config, order) {
-    return (config.patchPolicy?.reservedRanges?.find((range) => order >= range.from && order <= range.to) ??
-        null);
-}
-/**
- * Scans downward from just below the reserved block for the first order
- * not occupied by an existing patch. Returns null when every positive
- * order below the block is taken.
- */
-function firstFreeOrderBelowReservedRange(patches, range) {
-    const occupied = new Set(patches.map((patch) => patch.order));
-    for (let order = range.from - 1; order >= 1; order--) {
-        if (!occupied.has(order))
-            return order;
-    }
-    return null;
-}
-/**
- * Refuses positional placement plans whose renumber would touch a
- * `patchPolicy.reservedRanges` block, either by moving a patch into a
- * reserved range or by moving a patch that currently sits inside one.
- * Throws a single up-front error for the first reserved range hit (the
- * per-patch alternative surfaced one confusing finding per shifted
- * patch), suggesting the first free `--order` below the block when one
- * exists. Exact `--order` plans have an empty rename map and pass.
- */
-export function assertPlacementAvoidsReservedRanges(plan, manifestPatches, config) {
-    if (config?.patchPolicy === undefined || plan.renameMap.size === 0)
-        return;
-    const byFilename = new Map(manifestPatches.map((patch) => [patch.filename, patch]));
-    for (const [filename, rename] of plan.renameMap) {
-        const oldOrder = byFilename.get(filename)?.order;
-        const reserved = findReservedRange(config, rename.newOrder) ??
-            (oldOrder !== undefined ? findReservedRange(config, oldOrder) : null);
-        if (reserved === null)
-            continue;
-        const label = formatOrderRange(reserved);
-        const freeOrder = firstFreeOrderBelowReservedRange(manifestPatches, reserved);
-        if (freeOrder !== null) {
-            throw new InvalidArgumentError(`Positional insert would renumber the reserved range ${label}; ` +
-                `pass --order ${formatPatchOrder(freeOrder)} (first free order below the ` +
-                'reserved block) to place the new patch without renumbering reserved patches.', 'export placement');
-        }
-        throw new InvalidArgumentError(`Positional insert would renumber the reserved range ${label}; ` +
-            'no free order exists below the reserved block. Choose an unused --order outside ' +
-            'the reserved range or adjust patchPolicy.reservedRanges.', 'export placement');
-    }
-}

package/dist/src/commands/export-shared.d.ts

@@ -1,152 +0,0 @@
-import type { LintIgnoreChecks } from '../core/patch-lint-ignore.js';
-import type { PatchesManifest, PatchLintIssue } from '../types/commands/index.js';
-import type { ExportOptions, PatchCategory } from '../types/commands/index.js';
-import type { FireForgeConfig } from '../types/config.js';
-import type { SpinnerHandle } from '../utils/logger.js';
-export interface RunPatchLintOptions {
-    /** Engine root directory. */
-    engineDir: string;
-    /** Files touched by the patch. */
-    filesAffected: string[];
-    /** Raw unified diff string. */
-    diffContent: string;
-    /** Project configuration. */
-    config: FireForgeConfig;
-    /** If true, downgrade errors to warnings. */
-    skipLint?: boolean | undefined;
-    /** Optional cross-patch context for ownership resolution. */
-    patchQueueCtx?: import('../core/patch-lint-cross.js').PatchQueueContext | undefined;
-    /**
-     * Optional per-patch set of `check` IDs to suppress (threaded from
-     * `PatchMetadata.lintIgnore`). Surgical alternative to `--skip-lint` when
-     * exactly one advisory rule does not apply to a specific patch, e.g.
-     * `large-patch-lines` on a cohesive branding bundle that genuinely cannot
-     * be split.
-     */
-    ignoreChecks?: LintIgnoreChecks | undefined;
-    /**
-     * Optional explicit tier override (threaded from `PatchMetadata.tier`).
-     * Forces the branding-tier thresholds when set, independent of the
-     * auto-detect allowlist. When the branding tier is applied, a single
-     * `info()` line surfaces the choice so the tier decision is visible rather
-     * than silent.
-     */
-    patchTier?: 'branding' | undefined;
-}
-/**
- * Runs the full patch lint pipeline and reports results. Warnings are always
- * displayed. Errors block the export unless skipLint is true.
- *
- * @param options - See {@link RunPatchLintOptions}
- */
-export declare function runPatchLint(options: RunPatchLintOptions): Promise<void>;
-/**
- * Prints a patch-lint issue list with `runPatchLint`'s exact severity
- * buckets and skip-lint semantics, throwing on errors unless `skipLint`.
- * Factored out so `re-export`'s cached-lint path can replay
- * stored issues through the identical reporter without re-linting.
- */
-export declare function reportPatchLintOutcome(issues: PatchLintIssue[], skipLint?: boolean): void;
-/** Patch identity resolved for an export, from flags or interactive prompts. */
-export interface ExportPatchMetadata {
-    /** Normalized patch name (without order prefix or extension). */
-    patchName: string;
-    /** Category the patch is filed under. */
-    selectedCategory: PatchCategory;
-    /** Human-readable patch description. */
-    description: string;
-}
-/**
- * Resolves patch metadata interactively or from flags, with shared validation.
- * @param options - Export command options
- * @param isInteractive - Whether interactive prompts are allowed
- * @param commandName - Command name for error/help text
- */
-export declare function promptExportPatchMetadata(options: ExportOptions, isInteractive: boolean, commandName: 'export' | 'export-all', config?: FireForgeConfig): Promise<ExportPatchMetadata | null>;
-/**
- * Confirms whether an export may supersede existing patches.
- * @param patchesDir - Patches directory
- * @param filesAffected - Files touched by the pending export
- * @param supersede - Explicit supersede flag from CLI options
- * @param isInteractive - Whether interactive prompts are allowed
- * @param s - Active spinner handle to stop before prompting
- */
-export declare function confirmSupersedePatches(patchesDir: string, filesAffected: string[], supersede: boolean | undefined, isInteractive: boolean, s: SpinnerHandle): Promise<boolean>;
-/**
- * Detects new files missing license headers and offers to add them.
- *
- * In interactive mode the user is prompted before any files are modified. In
- * non-interactive mode the function is a no-op. The existing lint error
- * blocks the export instead.
- *
- * @param engineDir - Absolute path to engine directory
- * @param diffContent - Current unified diff
- * @param config - Project configuration
- * @param isInteractive - Whether interactive prompts are available
- * @param dryRun - When true, only report missing headers, never prompt or
- *   write. Dry-run must stay read-only: without this flag an interactive
- *   `export --dry-run` prompts (default Yes), writes license headers into
- *   engine/ files, and then closes with "no changes made".
- * @returns true if files were modified on disk (caller must regenerate diff)
- */
-export declare function autoFixLicenseHeaders(engineDir: string, diffContent: string, config: FireForgeConfig, isInteractive: boolean, dryRun?: boolean): Promise<boolean>;
-/**
- * Maps every file in `filesAffected` to the existing patches that already
- * claim ownership of it, excluding the caller's own patch (when `newFilename`
- * is provided) and any patches that the caller intends to fully supersede.
- *
- * Returns an empty map when no overlap exists. Used by the overlap gate in
- * `export` and `export-all` to refuse a default-mode export that would
- * silently create cross-patch ownership conflicts, the same class of
- * conflict `verify` immediately fails with.
- */
-export declare function findPartialOwnershipOverlap(manifest: PatchesManifest, filesAffected: string[], excludeFilenames: ReadonlySet<string>): Map<string, string[]>;
-/**
- * Gate that refuses the default export path when the new patch would
- * silently claim files already tracked by other non-superseded patches.
- * `findAllPatchesForFiles` catches the full-coverage supersede case. This
- * fills the gap for partial overlap: two patches both claiming e.g.
- * `browser/themes/shared/jar.inc.mn` after a second export with `--before`.
- *
- * Proceeds silently when there is no overlap, or when the caller passed
- * `--allow-overlap`. In interactive mode the caller is prompted to
- * acknowledge the overlap (the proper fix path is `re-export --files` to
- * repartition ownership, so the prompt surfaces that pointer). In
- * non-interactive mode it throws, since failing fast beats letting the
- * queue fall out of sync with verify.
- */
-export declare function guardOwnershipOverlap(args: {
-    patchesDir: string;
-    filesAffected: string[];
-    supersedingFilenames: ReadonlySet<string>;
-    allowOverlap: boolean;
-    isInteractive: boolean;
-    s: SpinnerHandle;
-}): Promise<boolean>;
-/**
- * Runs the two pre-commit gates shared by `export` and `export-all` in
- * order: the supersede confirmation, then the cross-patch ownership overlap
- * guard. The overlap guard receives the filenames of the patches the export
- * would fully supersede so it does not flag a file claimed by a patch that
- * is about to be removed. Catching only full-coverage supersedes leaves a
- * second export targeting a shared file creating a queue where two patches
- * both claim it and `verify` fails immediately.
- *
- * @param args - Gate inputs shared by both export commands
- * @param args.patchesDir - Absolute path of the patches directory
- * @param args.filesAffected - Engine-relative files the export claims
- * @param args.supersede - The command's `--supersede` flag
- * @param args.allowOverlap - The command's `--allow-overlap` flag
- * @param args.isInteractive - Whether prompting the operator is possible
- * @param args.s - Active spinner, stopped before any prompt
- * @returns `true` when both gates passed, `false` when the operator declined
- *   (the caller returns without committing)
- */
-export declare function runSupersedeAndOverlapGates(args: {
-    patchesDir: string;
-    filesAffected: string[];
-    supersede: boolean | undefined;
-    allowOverlap: boolean;
-    isInteractive: boolean;
-    s: SpinnerHandle;
-}): Promise<boolean>;

package/dist/src/commands/export-shared.js

@@ -1,396 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { join } from 'node:path';
-import { confirm, select, text } from '@clack/prompts';
-import { addLicenseHeaderToFile, hasThirdPartyPermissiveBanner } from '../core/license-headers.js';
-import { findAllPatchesForFiles } from '../core/patch-export.js';
-import { commentStyleForFile, detectNewFilesInDiff, formatPatchLintIssue, isAcceptableNewFileHeader, lintExportedPatch, resolvePatchSizeTier, } from '../core/patch-lint.js';
-import { resolvePatchOwnedSysMjs } from '../core/patch-lint-ownership.js';
-import { loadPatchesManifest } from '../core/patch-manifest.js';
-import { getPatchPolicyCategories, isCategoryAllowedByConfig } from '../core/patch-policy.js';
-import { GeneralError, InvalidArgumentError } from '../errors/base.js';
-import { pathExists, readText } from '../utils/fs.js';
-import { cancel, info, isCancel, warn } from '../utils/logger.js';
-import { describePatchNameProblem, normalizePatchDisplayName, PATCH_CATEGORIES, } from '../utils/validation.js';
-/**
- * Runs the full patch lint pipeline and reports results. Warnings are always
- * displayed. Errors block the export unless skipLint is true.
- *
- * @param options - See {@link RunPatchLintOptions}
- */
-export async function runPatchLint(options) {
-    const { engineDir, filesAffected, diffContent, config, skipLint, patchQueueCtx, ignoreChecks, patchTier, } = options;
-    // Compute the tier decision independently of the lint pipeline so it can
-    // be surfaced even when the rule body emitted no issues. A branding patch
-    // under the soft threshold still benefits from operators knowing which
-    // tier governed the run. The same helper is reused inside `lintPatchSize`,
-    // so the surfaced tier and the tier that actually drove the thresholds
-    // never drift.
-    const tierDecision = resolvePatchSizeTier(filesAffected, patchTier);
-    if (tierDecision.tier === 'branding') {
-        info(tierDecision.source === 'explicit'
-            ? 'Lint: branding threshold tier applied via patches.json `tier: "branding"` opt-in.'
-            : 'Lint: branding threshold tier applied (patch is all under browser/branding/ plus registration siblings).');
-    }
-    // When a whole-queue context is supplied, checkJs resolves cross-patch
-    // `resource:///`/`chrome://` imports against every patch-owned module, but
-    // only this patch's own new modules should report diagnostics. Scope the
-    // report to the files this diff creates so re-exporting one patch does not
-    // surface another patch's findings (and no ambient stub shim is needed).
-    const checkJsReportScope = patchQueueCtx
-        ? resolvePatchOwnedSysMjs(detectNewFilesInDiff(diffContent))
-        : undefined;
-    const issues = await lintExportedPatch(engineDir, filesAffected, diffContent, config, {
-        ...(patchQueueCtx ? { patchQueueCtx } : {}),
-        ...(ignoreChecks ? { ignoreChecks } : {}),
-        ...(patchTier ? { patchTier } : {}),
-        ...(checkJsReportScope ? { checkJsReportScope } : {}),
-    });
-    reportPatchLintOutcome(issues, skipLint);
-}
-/**
- * Prints a patch-lint issue list with `runPatchLint`'s exact severity
- * buckets and skip-lint semantics, throwing on errors unless `skipLint`.
- * Factored out so `re-export`'s cached-lint path can replay
- * stored issues through the identical reporter without re-linting.
- */
-export function reportPatchLintOutcome(issues, skipLint) {
-    if (issues.length === 0)
-        return;
-    const errors = issues.filter((i) => i.severity === 'error');
-    const warnings = issues.filter((i) => i.severity === 'warning');
-    const notices = issues.filter((i) => i.severity === 'notice');
-    for (const issue of notices) {
-        info(`NOTICE ${formatPatchLintIssue(issue)}`);
-    }
-    for (const issue of warnings) {
-        warn(formatPatchLintIssue(issue));
-    }
-    if (errors.length > 0) {
-        for (const issue of errors) {
-            if (skipLint) {
-                warn(formatPatchLintIssue(issue));
-            }
-            else {
-                warn(`ERROR ${formatPatchLintIssue(issue)}`);
-            }
-        }
-        if (!skipLint) {
-            throw new GeneralError(`Patch lint found ${errors.length} error(s) that must be fixed before exporting.\n` +
-                'Use --skip-lint to bypass this check.');
-        }
-        info(`Lint: ${errors.length} error(s) downgraded to warnings (--skip-lint)`);
-    }
-    else if (skipLint) {
-        // Always announce that --skip-lint was honoured, even when there were
-        // no errors to downgrade, so the operator can confirm the flag took
-        // effect. Without this, a clean `--skip-lint` run emitted nothing
-        // about the flag and looked identical to an unflagged run.
-        info('Lint: 0 error(s); --skip-lint is active (no effect on this run).');
-    }
-    const warnCount = warnings.length + (skipLint ? errors.length : 0);
-    if (warnCount > 0) {
-        info(`Patch lint: ${warnCount} warning(s)`);
-    }
-}
-/**
- * Resolves patch metadata interactively or from flags, with shared validation.
- * @param options - Export command options
- * @param isInteractive - Whether interactive prompts are allowed
- * @param commandName - Command name for error/help text
- */
-export async function promptExportPatchMetadata(options, isInteractive, commandName, config) {
-    const categories = config !== undefined ? getPatchPolicyCategories(config) : [...PATCH_CATEGORIES];
-    // A filename-shaped `--name foo.patch` must not die on the dot rule, so
-    // strip the extension before validation and the one-step flow works for
-    // both name shapes.
-    let patchName = options.name?.trim().replace(/\.patch$/i, '');
-    if (patchName) {
-        const validationError = describePatchNameProblem(patchName);
-        if (validationError) {
-            throw new InvalidArgumentError(validationError, '--name');
-        }
-    }
-    if (!patchName && !isInteractive) {
-        throw new InvalidArgumentError('The --name flag is required in non-interactive mode', `Use: fireforge ${commandName} ${commandName === 'export' ? '<paths...> ' : ''}--name "my-patch-name" --category ${categories[0] ?? 'ui'}`);
-    }
-    if (!patchName) {
-        const nameResult = await text({
-            message: 'Enter a name for this patch:',
-            placeholder: commandName === 'export' ? 'my-change' : 'my-changes',
-            validate: (value) => describePatchNameProblem((value ?? '').trim()),
-        });
-        if (isCancel(nameResult)) {
-            cancel('Export cancelled');
-            return null;
-        }
-        patchName = nameResult.trim();
-    }
-    let category = options.category;
-    if (category) {
-        const isAllowed = config !== undefined
-            ? isCategoryAllowedByConfig(config, category)
-            : PATCH_CATEGORIES.includes(category);
-        if (!isAllowed) {
-            throw new InvalidArgumentError(`Invalid category. Must be one of: ${categories.join(', ')}`, '--category');
-        }
-    }
-    else if (!isInteractive) {
-        throw new InvalidArgumentError('The --category flag is required in non-interactive mode', `Use: fireforge ${commandName} ${commandName === 'export' ? '<paths...> ' : ''}--name "name" --category <${categories.join('|')}>`);
-    }
-    else {
-        const categoryResult = await select({
-            message: 'Select a category for this patch:',
-            options: categories.map((value) => ({ value, label: value })),
-        });
-        if (isCancel(categoryResult)) {
-            cancel('Export cancelled');
-            return null;
-        }
-        category = categoryResult;
-    }
-    let description = options.description ?? '';
-    if (!description && isInteractive) {
-        const descResult = await text({
-            message: 'Enter a description (optional):',
-            placeholder: 'Brief description of what this patch does',
-        });
-        if (!isCancel(descResult)) {
-            description = descResult;
-        }
-    }
-    // The filename slug pipeline strips redundant category prefixes. The
-    // manifest display name must agree, or every `export --name ui-foo`
-    // needs a follow-up `patch rename` to satisfy bare-slug naming policy.
-    const normalized = normalizePatchDisplayName(patchName, category);
-    if (normalized !== patchName) {
-        info(`Patch name normalized: "${patchName}" → "${normalized}" (the filename carries the order and category prefix).`);
-    }
-    return {
-        patchName: normalized,
-        selectedCategory: category,
-        description,
-    };
-}
-/**
- * Confirms whether an export may supersede existing patches.
- * @param patchesDir - Patches directory
- * @param filesAffected - Files touched by the pending export
- * @param supersede - Explicit supersede flag from CLI options
- * @param isInteractive - Whether interactive prompts are allowed
- * @param s - Active spinner handle to stop before prompting
- */
-export async function confirmSupersedePatches(patchesDir, filesAffected, supersede, isInteractive, s) {
-    const wouldSupersede = await findAllPatchesForFiles(patchesDir, filesAffected);
-    if (wouldSupersede.length === 0 || supersede) {
-        return true;
-    }
-    s.stop();
-    const count = wouldSupersede.length;
-    warn(`This export would supersede ${count} existing patch${count === 1 ? '' : 'es'}:`);
-    for (const patch of wouldSupersede) {
-        warn(`  - ${patch.filename}`);
-    }
-    if (!isInteractive) {
-        throw new GeneralError(`Refusing to supersede ${count} patch${count === 1 ? '' : 'es'} in non-interactive mode. ` +
-            'Use --supersede to confirm, or use "fireforge re-export" to update existing patches in place.');
-    }
-    const confirmed = await confirm({
-        message: `Supersede ${count} patch${count === 1 ? '' : 'es'}? This cannot be undone.`,
-        initialValue: false,
-    });
-    if (isCancel(confirmed) || !confirmed) {
-        cancel('Export cancelled');
-        return false;
-    }
-    return true;
-}
-/**
- * Detects new files missing license headers and offers to add them.
- *
- * In interactive mode the user is prompted before any files are modified. In
- * non-interactive mode the function is a no-op. The existing lint error
- * blocks the export instead.
- *
- * @param engineDir - Absolute path to engine directory
- * @param diffContent - Current unified diff
- * @param config - Project configuration
- * @param isInteractive - Whether interactive prompts are available
- * @param dryRun - When true, only report missing headers, never prompt or
- *   write. Dry-run must stay read-only: without this flag an interactive
- *   `export --dry-run` prompts (default Yes), writes license headers into
- *   engine/ files, and then closes with "no changes made".
- * @returns true if files were modified on disk (caller must regenerate diff)
- */
-export async function autoFixLicenseHeaders(engineDir, diffContent, config, isInteractive, dryRun = false) {
-    const license = config.license ?? 'MPL-2.0';
-    const newFiles = detectNewFilesInDiff(diffContent);
-    if (newFiles.size === 0)
-        return false;
-    const filesToFix = [];
-    const vendoredFiles = [];
-    for (const file of newFiles) {
-        const style = commentStyleForFile(file);
-        if (!style)
-            continue;
-        const filePath = join(engineDir, file);
-        if (!(await pathExists(filePath)))
-            continue;
-        const content = await readText(filePath);
-        // Same acceptance policy as the missing-license-header rule: offering
-        // to "fix" a file the lint already accepts (e.g. a verbatim upstream
-        // MPL block header on a derived JS/CSS file) would stack a second
-        // header on top of a legitimate one.
-        if (!isAcceptableNewFileHeader(file, content, style, license)) {
-            // A recognized third-party permissive banner marks the file as
-            // vendored: prepending the project's own license header would break
-            // byte-identity pins and mislicense upstream code.
-            if (hasThirdPartyPermissiveBanner(content)) {
-                vendoredFiles.push(file);
-            }
-            else {
-                filesToFix.push(file);
-            }
-        }
-    }
-    if (vendoredFiles.length > 0) {
-        const vendoredList = vendoredFiles.map((f) => `  - ${f}`).join('\n');
-        info(`${vendoredFiles.length} new file(s) carry a third-party permissive license banner and ` +
-            'were left untouched (vendored); if the missing-license-header lint check flags them, ' +
-            `waive it with --lint-ignore missing-license-header:\n${vendoredList}`);
-    }
-    if (filesToFix.length === 0)
-        return false;
-    if (dryRun) {
-        const fileList = filesToFix.map((f) => `  - ${f}`).join('\n');
-        info(`[dry-run] ${filesToFix.length} new file(s) missing the ${license} license header ` +
-            `(a real export would offer to add them):\n${fileList}`);
-        return false;
-    }
-    if (!isInteractive)
-        return false;
-    const fileList = filesToFix.map((f) => `  - ${f}`).join('\n');
-    info(`${filesToFix.length} new file(s) missing the ${license} license header:\n${fileList}`);
-    const confirmed = await confirm({
-        message: `Add ${license} headers to ${filesToFix.length} file(s)?`,
-        initialValue: true,
-    });
-    if (isCancel(confirmed) || !confirmed)
-        return false;
-    for (const file of filesToFix) {
-        const style = commentStyleForFile(file);
-        if (!style)
-            continue;
-        const filePath = join(engineDir, file);
-        await addLicenseHeaderToFile(filePath, license, style);
-        info(`Added ${license} header to ${file}`);
-    }
-    return true;
-}
-/**
- * Maps every file in `filesAffected` to the existing patches that already
- * claim ownership of it, excluding the caller's own patch (when `newFilename`
- * is provided) and any patches that the caller intends to fully supersede.
- *
- * Returns an empty map when no overlap exists. Used by the overlap gate in
- * `export` and `export-all` to refuse a default-mode export that would
- * silently create cross-patch ownership conflicts, the same class of
- * conflict `verify` immediately fails with.
- */
-export function findPartialOwnershipOverlap(manifest, filesAffected, excludeFilenames) {
-    const overlap = new Map();
-    const targetSet = new Set(filesAffected);
-    for (const patch of manifest.patches) {
-        if (excludeFilenames.has(patch.filename))
-            continue;
-        for (const file of patch.filesAffected) {
-            if (!targetSet.has(file))
-                continue;
-            const owners = overlap.get(file) ?? [];
-            owners.push(patch.filename);
-            overlap.set(file, owners);
-        }
-    }
-    return overlap;
-}
-/**
- * Gate that refuses the default export path when the new patch would
- * silently claim files already tracked by other non-superseded patches.
- * `findAllPatchesForFiles` catches the full-coverage supersede case. This
- * fills the gap for partial overlap: two patches both claiming e.g.
- * `browser/themes/shared/jar.inc.mn` after a second export with `--before`.
- *
- * Proceeds silently when there is no overlap, or when the caller passed
- * `--allow-overlap`. In interactive mode the caller is prompted to
- * acknowledge the overlap (the proper fix path is `re-export --files` to
- * repartition ownership, so the prompt surfaces that pointer). In
- * non-interactive mode it throws, since failing fast beats letting the
- * queue fall out of sync with verify.
- */
-export async function guardOwnershipOverlap(args) {
-    const { patchesDir, filesAffected, supersedingFilenames, allowOverlap, isInteractive, s } = args;
-    if (allowOverlap)
-        return true;
-    const manifest = await loadPatchesManifest(patchesDir);
-    if (!manifest)
-        return true;
-    const overlap = findPartialOwnershipOverlap(manifest, filesAffected, supersedingFilenames);
-    if (overlap.size === 0)
-        return true;
-    s.stop();
-    const entries = [...overlap.entries()].sort(([a], [b]) => a.localeCompare(b));
-    warn(`This export would create cross-patch ownership overlap on ${entries.length} file${entries.length === 1 ? '' : 's'}:`);
-    for (const [file, owners] of entries) {
-        warn(`  - ${file} already claimed by: ${owners.join(', ')}`);
-    }
-    warn('The queue would fail `fireforge verify` immediately after this export. ' +
-        'To repartition ownership safely, run `fireforge re-export --files <paths> <existing-patch>` ' +
-        'on the overlapping patches first, then re-run the export.');
-    if (!isInteractive) {
-        throw new GeneralError('Refusing to export a queue with cross-patch ownership overlap in non-interactive mode. ' +
-            'Pass --allow-overlap to acknowledge the conflict, or repartition ownership via `fireforge re-export --files`.');
-    }
-    const confirmed = await confirm({
-        message: 'Proceed with overlapping ownership? This will leave the queue in a verify-failing state.',
-        initialValue: false,
-    });
-    if (isCancel(confirmed) || !confirmed) {
-        cancel('Export cancelled');
-        return false;
-    }
-    return true;
-}
-/**
- * Runs the two pre-commit gates shared by `export` and `export-all` in
- * order: the supersede confirmation, then the cross-patch ownership overlap
- * guard. The overlap guard receives the filenames of the patches the export
- * would fully supersede so it does not flag a file claimed by a patch that
- * is about to be removed. Catching only full-coverage supersedes leaves a
- * second export targeting a shared file creating a queue where two patches
- * both claim it and `verify` fails immediately.
- *
- * @param args - Gate inputs shared by both export commands
- * @param args.patchesDir - Absolute path of the patches directory
- * @param args.filesAffected - Engine-relative files the export claims
- * @param args.supersede - The command's `--supersede` flag
- * @param args.allowOverlap - The command's `--allow-overlap` flag
- * @param args.isInteractive - Whether prompting the operator is possible
- * @param args.s - Active spinner, stopped before any prompt
- * @returns `true` when both gates passed, `false` when the operator declined
- *   (the caller returns without committing)
- */
-export async function runSupersedeAndOverlapGates(args) {
-    const { patchesDir, filesAffected, supersede, allowOverlap, isInteractive, s } = args;
-    const shouldProceed = await confirmSupersedePatches(patchesDir, filesAffected, supersede, isInteractive, s);
-    if (!shouldProceed)
-        return false;
-    const willSupersede = await findAllPatchesForFiles(patchesDir, filesAffected);
-    const supersedingFilenames = new Set(willSupersede.map((p) => p.filename));
-    return guardOwnershipOverlap({
-        patchesDir,
-        filesAffected,
-        supersedingFilenames,
-        allowOverlap,
-        isInteractive,
-        s,
-    });
-}

package/dist/src/commands/export-staged-registration.d.ts

@@ -1,46 +0,0 @@
-/**
- * Lets `export --order` land a new system module whose moz.build line is
- * still unexported working-tree drift in the patch that registers it.
- *
- * Without this the two refusals deadlock: the module's export fails
- * `unregistered-system-module` because no patch body carries its moz.build
- * line yet, and the registering patch cannot be re-exported first because
- * its line names a file no patch creates. The way through is
- * declared intent plus evidence: when the registering patch carries a
- * staged registration for the module and the working tree's moz.build has
- * exactly that line, the export is accepted and the operator is told to
- * re-export the registering patch next. Without the declaration the
- * refusal names the steps, with the exact `patch staged-dependency`
- * command, instead of stopping at "register it".
- *
- * Consumed by export-flow.ts.
- */
-import type { PatchQueueContext } from '../core/patch-lint.js';
-import type { PatchLintIssue } from '../types/commands/index.js';
-/** Result of {@link acceptTreeRegisteredModules}. */
-export interface TreeRegistrationOutcome {
-    /** The projected errors left after accepted modules are removed. */
-    remaining: PatchLintIssue[];
-    /** One note per accepted module, naming the re-export to run next. */
-    accepted: string[];
-    /** Detail lines for modules whose registration is in the tree but undeclared. */
-    advice: string[];
-}
-/**
- * Removes `unregistered-system-module` findings for modules the pending
- * export creates when a queue patch declares their registration as a
- * staged dependency and the working tree's moz.build carries that line.
- * For a module whose line is in the tree but undeclared, returns the steps
- * that make it acceptable.
- *
- * @param args - The engine directory (the working tree), the current queue,
- *   the filename the pending export would take, the files it creates, and
- *   the placement projection's error findings
- */
-export declare function acceptTreeRegisteredModules(args: {
-    engineDir: string;
-    baseCtx: PatchQueueContext;
-    newFilename: string;
-    pendingNewFiles: ReadonlySet<string>;
-    projectedIssues: readonly PatchLintIssue[];
-}): Promise<TreeRegistrationOutcome>;