@hominis/fireforge 0.55.0 → 0.60.0

package/dist/src/commands/patch/staged-dependency-validate.js

@@ -1,78 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Shape validation for `patch staged-dependency --add`.
- *
- * `--creates`/`--file` take engine-relative file paths, while `--owner`
- * takes a patch filename. Accepting all three as arbitrary strings lets a
- * `--creates <patch-name>` mixup produce a declaration nothing can ever
- * discharge, surfacing only later as a `staged-dependency-unused` warning.
- * Refusals here fire only on a clear patch-name shape (slash-free values
- * that end in `.patch` or match a queue patch filename/stem): legitimate
- * engine paths always contain a `/`, so deep paths can never
- * false-positive.
- */
-import { join } from 'node:path';
-import { extractAddedLinesPerFile } from '../../core/patch-lint-diff.js';
-import { patchAddsRegistrationLine } from '../../core/patch-lint-staged-registration.js';
-import { InvalidArgumentError } from '../../errors/base.js';
-import { pathExists, readText } from '../../utils/fs.js';
-import { warn } from '../../utils/logger.js';
-function matchQueuePatch(value, queuePatches) {
-    return queuePatches.find((patch) => patch.filename === value || patch.filename === `${value}.patch`)?.filename;
-}
-function refusePatchShapedPath(flag, value, role, queuePatches) {
-    if (value.includes('/'))
-        return;
-    const matched = matchQueuePatch(value, queuePatches);
-    if (matched === undefined && !value.endsWith('.patch'))
-        return;
-    const evidence = matched !== undefined ? `matches patch ${matched} in the queue` : 'looks like a patch filename';
-    throw new InvalidArgumentError(`${flag} takes ${role} (e.g. browser/components/foo/Foo.sys.mjs), not a patch name — ` +
-        `"${value}" ${evidence}. If you meant to name the owning patch, pass it with --owner.`, flag);
-}
-/**
- * Validates the `--add` declaration fields against the loaded queue.
- * Throws on a clear flag mixup. Warns (only) when `--owner` is
- * well-formed but absent from the queue, because the owner may
- * legitimately be exported moments later and renumbering rewrites owners.
- */
-export function validateStagedDependencyAdd(dependency, queuePatches) {
-    refusePatchShapedPath('--creates', dependency.creates, 'the engine-relative path of the file a later patch creates', queuePatches);
-    refusePatchShapedPath('--file', dependency.file, 'the engine-relative file containing the declaring site inside this patch', queuePatches);
-    const owner = dependency.owner;
-    if (owner === undefined)
-        return;
-    if (owner.includes('/') || !owner.endsWith('.patch')) {
-        throw new InvalidArgumentError(`--owner names the owning patch artifact (e.g. 012-infra-foo.patch); ` +
-            `"${owner}" does not look like a patch filename. The created file path goes in --creates.`, '--owner');
-    }
-    if (!queuePatches.some((patch) => patch.filename === owner)) {
-        warn(`--owner ${owner} matches no patch currently in the queue. The declaration only ` +
-            'discharges once a patch with exactly this filename creates the --creates path.');
-    }
-}
-/**
- * Warns when a registration's `--line` matches no line the patch body adds
- * to `--file`, compared whitespace-insensitively as the lint compares it.
- * Advisory only: the patch may be re-exported with the line moments later,
- * but until then the lint reports the declaration as
- * `staged-dependency-unused`.
- *
- * @param registration - The declaration being added
- * @param patchesDir - Patches directory holding the target patch body
- * @param patchFilename - The declaring patch
- */
-export async function warnRegistrationLineNotAdded(registration, patchesDir, patchFilename) {
-    const patchPath = join(patchesDir, patchFilename);
-    if (!(await pathExists(patchPath)))
-        return;
-    const added = extractAddedLinesPerFile(await readText(patchPath)).get(registration.file) ?? [];
-    const additions = new Map([[registration.file, added.join('\n')]]);
-    if (patchAddsRegistrationLine({ newFiles: new Map(), modifiedFileAdditions: additions }, registration.file, registration.line)) {
-        return;
-    }
-    warn(`--line matches no line ${patchFilename} adds to ${registration.file} ` +
-        '(compared whitespace-insensitively). The declaration is written, but lint reports it as ' +
-        'staged-dependency-unused until the patch adds that line: copy the line from the patch ' +
-        'hunk, or re-export the patch first.');
-}

package/dist/src/commands/patch/staged-dependency.d.ts

@@ -1,22 +0,0 @@
-/**
- * `fireforge patch staged-dependency <name>` edits
- * PatchMetadata.stagedDependencies without rewriting the .patch body.
- */
-import { Command } from 'commander';
-import type { CommandContext } from '../../types/cli.js';
-import type { PatchStagedDependencyOptions } from '../../types/commands/index.js';
-/**
- * Runs the metadata-only staged-dependency mutation command.
- *
- * @param projectRoot - Project root directory
- * @param identifier - Patch filename, ordinal, or manifest name
- * @param options - Mutation mode, entry kind, and declaration fields
- */
-export declare function patchStagedDependencyCommand(projectRoot: string, identifier: string, options?: PatchStagedDependencyOptions): Promise<void>;
-/**
- * Registers the `patch staged-dependency` subcommand.
- *
- * @param parent - Parent `patch` command
- * @param context - Shared CLI registration context
- */
-export declare function registerPatchStagedDependency(parent: Command, context: CommandContext): void;

package/dist/src/commands/patch/staged-dependency.js

@@ -1,251 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge patch staged-dependency <name>` edits
- * PatchMetadata.stagedDependencies without rewriting the .patch body.
- */
-import { Command } from 'commander';
-import { appendHistoryBestEffort } from '../../core/history-log.js';
-import { mutatePatchMetadata } from '../../core/patch-export.js';
-import { GeneralError, InvalidArgumentError } from '../../errors/base.js';
-import { info, intro, outro } from '../../utils/logger.js';
-import { addWaitLockOption, resolveWaitLockSeconds } from '../../utils/options.js';
-import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
-import { stagedDependencyDelta } from './staged-dependency-batch.js';
-import { applyMode, countReasonUpdates, countStagedEntries, dependencyLabel, importView, registrationView, } from './staged-dependency-entries.js';
-import { runBatchAdd } from './staged-dependency-from.js';
-import { declarationNoun, inferRemovalKinds, selectRemovalEntries, } from './staged-dependency-remove.js';
-import { validateStagedDependencyAdd, warnRegistrationLineNotAdded, } from './staged-dependency-validate.js';
-/** Joins the names of the missing flags for error attribution. */
-function missingFlagList(pairs) {
-    return pairs
-        .filter(([, value]) => value === undefined || value === '')
-        .map(([flag]) => flag)
-        .join(', ');
-}
-function modeFromOptions(options) {
-    const adding = options.add === true;
-    const removing = options.remove === true;
-    const clearing = options.clear === true;
-    const modeCount = [adding, removing, clearing].filter(Boolean).length;
-    if (modeCount > 1) {
-        throw new InvalidArgumentError('--add, --remove, and --clear are mutually exclusive. Pick one mode per invocation.', '--add/--remove/--clear');
-    }
-    if (modeCount === 0) {
-        throw new InvalidArgumentError('Specify --add, --remove, or --clear.', '--add/--remove/--clear');
-    }
-    return adding ? 'add' : removing ? 'remove' : 'clear';
-}
-function kindFromOptions(options) {
-    const kind = options.kind ?? 'import';
-    if (kind !== 'import' && kind !== 'registration') {
-        throw new InvalidArgumentError(`--kind must be "import" or "registration" (got "${kind}").`, '--kind');
-    }
-    if (kind === 'import' && options.line !== undefined) {
-        throw new InvalidArgumentError('--line only applies to --kind registration; import declarations use --specifier.', '--line');
-    }
-    if (kind === 'registration' && options.specifier !== undefined) {
-        throw new InvalidArgumentError('--specifier only applies to --kind import; registration declarations use --line.', '--specifier');
-    }
-    return kind;
-}
-function requireForwardImportOptions(options) {
-    if (!options.file || !options.specifier || !options.creates) {
-        throw new InvalidArgumentError('--add requires --file, --specifier, and --creates.', missingFlagList([
-            ['--file', options.file],
-            ['--specifier', options.specifier],
-            ['--creates', options.creates],
-        ]));
-    }
-    const dependency = {
-        file: options.file,
-        specifier: options.specifier,
-        creates: options.creates,
-    };
-    if (options.owner !== undefined)
-        dependency.owner = options.owner;
-    if (options.reason !== undefined)
-        dependency.reason = options.reason;
-    return dependency;
-}
-function requireRegistrationOptions(options) {
-    if (!options.file || !options.line || !options.creates) {
-        throw new InvalidArgumentError('--add --kind registration requires --file, --line, and --creates.', missingFlagList([
-            ['--file', options.file],
-            ['--line', options.line],
-            ['--creates', options.creates],
-        ]));
-    }
-    const dependency = {
-        file: options.file,
-        line: options.line,
-        creates: options.creates,
-    };
-    if (options.owner !== undefined)
-        dependency.owner = options.owner;
-    if (options.reason !== undefined)
-        dependency.reason = options.reason;
-    return dependency;
-}
-/**
- * Renders a one-line summary of a staged-dependency metadata change.
- */
-function describeStagedDependencyChange(before, after, mode, kinds, targets) {
-    const beforeCount = countStagedEntries(before);
-    const afterCount = countStagedEntries(after);
-    const targetKinds = [...new Set(targets.map((target) => target.kind))];
-    const noun = declarationNoun(targetKinds.length > 0 ? targetKinds : kinds);
-    if (mode === 'clear') {
-        return beforeCount === 0
-            ? 'stagedDependencies was already empty — no change'
-            : `cleared ${beforeCount} staged dependency declaration(s)`;
-    }
-    const label = targets.map(({ kind, view }) => dependencyLabel(kind, view)).join('; ');
-    if (targets.length === 0)
-        return 'stagedDependencies unchanged';
-    if (mode === 'add') {
-        if (afterCount !== beforeCount)
-            return `added ${noun}: ${label}`;
-        return countReasonUpdates(before, after) > 0
-            ? `updated 1 ${noun} reason in place: ${label}`
-            : `${noun} already present: ${label}`;
-    }
-    return afterCount === beforeCount
-        ? `no ${noun} matched: ${label}`
-        : `removed ${beforeCount - afterCount} ${noun} declaration(s): ${label}`;
-}
-/**
- * Runs the metadata-only staged-dependency mutation command.
- *
- * @param projectRoot - Project root directory
- * @param identifier - Patch filename, ordinal, or manifest name
- * @param options - Mutation mode, entry kind, and declaration fields
- */
-export async function patchStagedDependencyCommand(projectRoot, identifier, options = {}) {
-    const isDryRun = options.dryRun === true;
-    intro(isDryRun ? 'FireForge patch staged-dependency (dry run)' : 'FireForge patch staged-dependency');
-    const mode = modeFromOptions(options);
-    if (options.from !== undefined) {
-        await runBatchAdd(projectRoot, identifier, mode, options);
-        return;
-    }
-    // Without --kind, --remove searches the kind its matcher names, or both.
-    const kinds = (mode === 'remove' ? inferRemovalKinds(options) : undefined) ?? [
-        kindFromOptions(options),
-    ];
-    const kind = kinds.length === 1 ? kinds[0] : undefined;
-    // The patch queue loads before the declaration fields resolve so
-    // `--remove` can infer `--creates` from the target patch's staged
-    // entries.
-    const { paths, manifest } = await requirePatchQueue(projectRoot);
-    const targetPatch = requirePatchTarget(identifier, manifest.patches);
-    const importDependency = mode === 'add' && kind === 'import' ? requireForwardImportOptions(options) : undefined;
-    const registrationDependency = mode === 'add' && kind === 'registration' ? requireRegistrationOptions(options) : undefined;
-    // Shape-check --add declarations against the loaded queue: a
-    // patch-name-shaped --creates/--file is refused here instead of surfacing
-    // later as an undischargeable staged-dependency-unused.
-    const added = importDependency ?? registrationDependency;
-    if (added !== undefined) {
-        validateStagedDependencyAdd(added, manifest.patches);
-    }
-    if (registrationDependency !== undefined) {
-        await warnRegistrationLineNotAdded(registrationDependency, paths.patches, targetPatch.filename);
-    }
-    const targets = mode === 'remove'
-        ? selectRemovalEntries(kinds, options, targetPatch.stagedDependencies)
-        : importDependency !== undefined
-            ? [{ kind: 'import', view: importView(importDependency) }]
-            : registrationDependency !== undefined
-                ? [{ kind: 'registration', view: registrationView(registrationDependency) }]
-                : [];
-    const applyKind = (entries, entryKind, toView, addition) => {
-        if (!kinds.includes(entryKind))
-            return [...entries];
-        const own = targets.filter((target) => target.kind === entryKind).map(({ view }) => view);
-        if (mode !== 'remove')
-            return applyMode(entries, mode, own[0], toView, addition);
-        return own.reduce((remaining, target) => applyMode(remaining, 'remove', target, toView, undefined), [...entries]);
-    };
-    const applyToStaged = (staged) => {
-        if (mode === 'clear')
-            return {};
-        const forwardImports = applyKind(staged?.forwardImports ?? [], 'import', importView, importDependency);
-        const registrations = applyKind(staged?.registrations ?? [], 'registration', registrationView, registrationDependency);
-        return {
-            ...(forwardImports.length > 0 ? { forwardImports } : {}),
-            ...(registrations.length > 0 ? { registrations } : {}),
-        };
-    };
-    const existing = targetPatch.stagedDependencies;
-    const projected = applyToStaged(existing);
-    const summary = describeStagedDependencyChange(existing, projected, mode, kinds, targets);
-    if (isDryRun) {
-        info(`[dry-run] ${targetPatch.filename}: ${summary}.`);
-        outro('Dry run complete — no changes made');
-        return;
-    }
-    const result = await mutatePatchMetadata(paths.patches, targetPatch.filename, (current) => {
-        const after = applyToStaged(current.stagedDependencies);
-        if (countStagedEntries(after) === 0)
-            return { unset: ['stagedDependencies'] };
-        return { set: { stagedDependencies: after } };
-    }, {
-        waitLockSeconds: resolveWaitLockSeconds(options.waitLock),
-        command: 'patch staged-dependency',
-    });
-    if (!result) {
-        throw new GeneralError(`Patch ${targetPatch.filename} disappeared from the manifest during the update. Re-run after investigating.`);
-    }
-    const before = result.before.stagedDependencies;
-    const after = result.after.stagedDependencies;
-    info(`${targetPatch.filename}: ${describeStagedDependencyChange(before, after, mode, kinds, targets)}.`);
-    if (mode === 'remove' && countStagedEntries(after) === countStagedEntries(before)) {
-        // The selection matched when the queue was read; a peer removed the
-        // entries before the locked write. Still a miss, so still a refusal.
-        throw new InvalidArgumentError(`${targetPatch.filename}: the selected staged declaration(s) were already gone when the manifest was written.`, '--remove');
-    }
-    await appendHistoryBestEffort(paths.patches, {
-        operation: 'patch-staged-dependency',
-        // Only the delta: the whole list on both sides grew the log
-        // quadratically with the list (see staged-dependency-batch.ts).
-        args: {
-            filename: targetPatch.filename,
-            mode,
-            // A kind-less --remove searched both kinds; the delta names which.
-            ...(kind !== undefined ? { kind } : {}),
-            ...stagedDependencyDelta(before, after),
-        },
-        ...(options.yes === true ? { yes: true } : {}),
-        result: 'ok',
-    }, `patch staged-dependency committed (${targetPatch.filename})`);
-    outro('Patch staged-dependency complete');
-}
-/**
- * Registers the `patch staged-dependency` subcommand.
- *
- * @param parent - Parent `patch` command
- * @param context - Shared CLI registration context
- */
-export function registerPatchStagedDependency(parent, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const command = parent
-        .command('staged-dependency <name>')
-        .description('Edit PatchMetadata.stagedDependencies on a single patch (no .patch body rewrite).')
-        .option('--add', 'Add a staged dependency declaration')
-        .option('--remove', 'Remove matching staged dependency declaration(s); a selection that matches nothing exits 8')
-        .option('--clear', 'Drop the stagedDependencies field entirely')
-        .option('--kind <kind>', 'Declaration shape: "import" (forward import, the default) or "registration" (jar.mn packaging line, customElements or actor registration); --remove without it takes the kind --specifier or --line names, or both kinds')
-        .option('--file <path>', 'Declaring file path relative to engine/')
-        .option('--specifier <specifier>', 'Exact import specifier as it appears in source (--kind import)')
-        .option('--line <text>', 'Registration/packaging line as the patch adds it, compared whitespace-insensitively (--kind registration)')
-        .option('--creates <path>', 'Later-created file path relative to engine/ (with --remove and no --file: removes every declaration for that path)')
-        .option('--owner <patch>', 'Exact later patch filename expected to create --creates')
-        .option('--reason <text>', 'Human-readable rationale stored with the declaration; --add on a declaration already present replaces its reason in place (with --from: the default for entries without one)')
-        .option('--from <json-file>', 'Add every declaration in a JSON file under one lock hold (--add only): a "lint --per-patch --report" ' +
-        "document (its findings' stagedDeclarations for this patch) or an array of " +
-        '{ file, specifier | line, creates, owner?, reason?, patch? } entries')
-        .option('--dry-run', 'Show what would change without writing')
-        .option('-y, --yes', 'Record scripted consent in the destructive-operation history log. This command never prompts; the flag exists for workflow uniformity with commands that do.');
-    addWaitLockOption(command).action(withErrorHandling(async (name, options) => {
-        await patchStagedDependencyCommand(getProjectRoot(), name, options);
-    }));
-}

package/dist/src/commands/patch/tier.d.ts

@@ -1,34 +0,0 @@
-/**
- * `fireforge patch tier <name>` sets or clears `PatchMetadata.tier` on a
- * single patch without rewriting the `.patch` file body.
- *
- * Companion to `fireforge re-export <name> --tier <tier>`. Re-export is the
- * right tool when the patch body itself needs regenerating. This subcommand
- * covers the metadata-only adjustment, where the operator has discovered
- * (from a `lint --per-patch` warning, say) that the threshold-tier override
- * should be set but the patch body is already correct. Avoiding the
- * re-export saves the engine read + diff regeneration roundtrip and leaves
- * the `.patch` file's mtime alone.
- *
- * Modes are mutually exclusive: exactly one of `--tier <branding>` or
- * `--clear` must be supplied per invocation.
- */
-import { Command } from 'commander';
-import type { CommandContext } from '../../types/cli.js';
-import type { PatchTierOptions } from '../../types/commands/index.js';
-/**
- * Runs the `patch tier` command: updates `PatchMetadata.tier` on the
- * named patch (or clears the field) and writes the manifest.
- *
- * @param projectRoot - Project root directory
- * @param identifier - Patch filename, ordinal, or manifest `name`
- * @param options - Command options
- */
-export declare function patchTierCommand(projectRoot: string, identifier: string, options?: PatchTierOptions): Promise<void>;
-/**
- * Registers the `patch tier` subcommand on the `patch` parent.
- *
- * @param parent - Parent Commander command
- * @param context - Shared CLI registration context
- */
-export declare function registerPatchTier(parent: Command, context: CommandContext): void;

package/dist/src/commands/patch/tier.js

@@ -1,125 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge patch tier <name>` sets or clears `PatchMetadata.tier` on a
- * single patch without rewriting the `.patch` file body.
- *
- * Companion to `fireforge re-export <name> --tier <tier>`. Re-export is the
- * right tool when the patch body itself needs regenerating. This subcommand
- * covers the metadata-only adjustment, where the operator has discovered
- * (from a `lint --per-patch` warning, say) that the threshold-tier override
- * should be set but the patch body is already correct. Avoiding the
- * re-export saves the engine read + diff regeneration roundtrip and leaves
- * the `.patch` file's mtime alone.
- *
- * Modes are mutually exclusive: exactly one of `--tier <branding>` or
- * `--clear` must be supplied per invocation.
- */
-import { Command, Option } from 'commander';
-import { confirmDestructive } from '../../core/destructive.js';
-import { appendHistoryBestEffort } from '../../core/history-log.js';
-import { updatePatchMetadata } from '../../core/patch-export.js';
-import { InvalidArgumentError } from '../../errors/base.js';
-import { info, intro, outro } from '../../utils/logger.js';
-import { addWaitLockOption, pickDefined, resolveWaitLockSeconds } from '../../utils/options.js';
-import { proceedAfterDecision } from '../destructive-decision.js';
-import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
-/**
- * Runs the `patch tier` command: updates `PatchMetadata.tier` on the
- * named patch (or clears the field) and writes the manifest.
- *
- * @param projectRoot - Project root directory
- * @param identifier - Patch filename, ordinal, or manifest `name`
- * @param options - Command options
- */
-export async function patchTierCommand(projectRoot, identifier, options = {}) {
-    const isDryRun = options.dryRun === true;
-    intro(isDryRun ? 'FireForge patch tier (dry run)' : 'FireForge patch tier');
-    // Mode mutex: a single invocation either sets or clears the tier.
-    // Combining both is ambiguous: the operator's intent is not obvious and
-    // silently picking one would mask the typo.
-    const setting = options.tier !== undefined;
-    const clearing = options.clear === true;
-    if (setting && clearing) {
-        throw new InvalidArgumentError('--tier and --clear are mutually exclusive. Pick one mode per invocation.', 'patch tier');
-    }
-    if (!setting && !clearing) {
-        throw new InvalidArgumentError('Specify --tier <tier> to set the override, or --clear to remove it.', 'patch tier');
-    }
-    const { paths, manifest } = await requirePatchQueue(projectRoot);
-    const target = requirePatchTarget(identifier, manifest.patches);
-    const before = target.tier;
-    const after = setting ? options.tier : undefined;
-    if (before === after) {
-        info(after === undefined
-            ? `${target.filename}: tier is already absent — no change.`
-            : `${target.filename}: tier is already "${after}" — no change.`);
-        outro(isDryRun ? 'Dry run complete — no changes made' : 'Patch tier (no-op)');
-        return;
-    }
-    const action = after === undefined
-        ? `clear tier (was "${before}")`
-        : before === undefined
-            ? `set tier to "${after}"`
-            : `change tier from "${before}" to "${after}"`;
-    // Destructive-operation contract (docs/lifecycle-invariants.md): manifest
-    // metadata mutations get summary + dry-run + confirmation/--yes + history
-    // uniformly, so --yes skips a real prompt rather than only appearing in
-    // the history record.
-    const decision = await confirmDestructive({
-        operation: 'patch-tier',
-        title: `Patch tier: ${target.filename}`,
-        summary: [`${target.filename}: ${action}`],
-        yes: options.yes === true,
-        dryRun: isDryRun,
-    });
-    if (!proceedAfterDecision(decision, 'Cancelled — no changes made'))
-        return;
-    // Single write under the patch directory lock (delegated inside
-    // updatePatchMetadata). Setting routes through `updates`. Clearing
-    // routes through `unsetFields` so TypeScript's exact optional types
-    // do not have to carry an explicit `undefined` on the `tier` field.
-    if (after !== undefined) {
-        await updatePatchMetadata(paths.patches, target.filename, { tier: after }, [], {
-            waitLockSeconds: resolveWaitLockSeconds(options.waitLock),
-            command: 'patch tier',
-        });
-    }
-    else {
-        await updatePatchMetadata(paths.patches, target.filename, {}, ['tier']);
-    }
-    await appendHistoryBestEffort(paths.patches, {
-        operation: 'patch-tier',
-        args: {
-            filename: target.filename,
-            ...(before !== undefined ? { before } : {}),
-            ...(after !== undefined ? { after } : {}),
-        },
-        ...(options.yes === true ? { yes: true } : {}),
-        result: 'ok',
-    }, `patch tier committed (${target.filename})`);
-    info(`${target.filename}: ${action}.`);
-    outro('Patch tier complete');
-}
-/**
- * Registers the `patch tier` subcommand on the `patch` parent.
- *
- * @param parent - Parent Commander command
- * @param context - Shared CLI registration context
- */
-export function registerPatchTier(parent, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const command = parent
-        .command('tier <name>')
-        .description('Set or clear PatchMetadata.tier on a single patch (no .patch body rewrite). Use --tier <branding> to set, --clear to remove.')
-        .addOption(new Option('--tier <tier>', 'Force the tier override on the patch (only "branding" recognised)').choices(['branding']))
-        .option('--clear', 'Remove the tier override (restores tier auto-detection)')
-        .option('--dry-run', 'Show what would change without writing')
-        .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)');
-    addWaitLockOption(command).action(withErrorHandling(async (name, options) => {
-        const { tier, ...rest } = options;
-        await patchTierCommand(getProjectRoot(), name, {
-            ...pickDefined(rest),
-            ...(tier !== undefined ? { tier: tier } : {}),
-        });
-    }));
-}

package/dist/src/commands/patch-rename-map.d.ts

@@ -1,30 +0,0 @@
-/**
- * Structural equality for patch rename maps, shared by the placement-mode
- * export preview/commit check (`export-flow.ts`) and `patch reorder`'s
- * under-lock drift check. One helper for the sorted-entries comparison
- * keeps the two commit gates from drifting.
- */
-import type { PatchRenameEntry } from '../core/patch-manifest.js';
-/**
- * Rename-map entries ordered by target order, so previews, history entries
- * and equality checks all walk the queue in its final on-disk order.
- */
-export declare function getSortedRenameEntries(renameMap: Map<string, PatchRenameEntry>): Array<[string, PatchRenameEntry]>;
-/**
- * Compares two rename maps entry by entry after sorting both by target
- * order. Equal when every (current filename, new filename, new order)
- * triple matches positionally.
- */
-export declare function renameMapsEqual(left: Map<string, PatchRenameEntry>, right: Map<string, PatchRenameEntry>): boolean;
-/**
- * Writes a committed rename map as one JSON object, old filename to new
- * filename in the queue's new order (`{}` when nothing was renumbered), so
- * a session can rewrite its references to the renumbered patches from the
- * file instead of from the printed summary. Used by `patch reorder
- * --map-out` and `patch split --map-out`.
- *
- * @param path - Output path, relative to the working directory
- * @param renameMap - The committed rename map
- * @returns The absolute path written
- */
-export declare function writeRenameMapFile(path: string, renameMap: Map<string, PatchRenameEntry>): Promise<string>;

package/dist/src/commands/patch-rename-map.js

@@ -1,54 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Structural equality for patch rename maps, shared by the placement-mode
- * export preview/commit check (`export-flow.ts`) and `patch reorder`'s
- * under-lock drift check. One helper for the sorted-entries comparison
- * keeps the two commit gates from drifting.
- */
-import { dirname, resolve } from 'node:path';
-import { ensureDir, writeJson } from '../utils/fs.js';
-/**
- * Rename-map entries ordered by target order, so previews, history entries
- * and equality checks all walk the queue in its final on-disk order.
- */
-export function getSortedRenameEntries(renameMap) {
-    return Array.from(renameMap.entries()).sort((a, b) => a[1].newOrder - b[1].newOrder);
-}
-/**
- * Compares two rename maps entry by entry after sorting both by target
- * order. Equal when every (current filename, new filename, new order)
- * triple matches positionally.
- */
-export function renameMapsEqual(left, right) {
-    const leftEntries = getSortedRenameEntries(left);
-    const rightEntries = getSortedRenameEntries(right);
-    if (leftEntries.length !== rightEntries.length) {
-        return false;
-    }
-    return leftEntries.every(([leftFilename, leftEntry], index) => {
-        const rightTuple = rightEntries[index];
-        if (!rightTuple)
-            return false;
-        const [rightFilename, rightEntry] = rightTuple;
-        return (leftFilename === rightFilename &&
-            leftEntry.newFilename === rightEntry.newFilename &&
-            leftEntry.newOrder === rightEntry.newOrder);
-    });
-}
-/**
- * Writes a committed rename map as one JSON object, old filename to new
- * filename in the queue's new order (`{}` when nothing was renumbered), so
- * a session can rewrite its references to the renumbered patches from the
- * file instead of from the printed summary. Used by `patch reorder
- * --map-out` and `patch split --map-out`.
- *
- * @param path - Output path, relative to the working directory
- * @param renameMap - The committed rename map
- * @returns The absolute path written
- */
-export async function writeRenameMapFile(path, renameMap) {
-    const absolute = resolve(path);
-    await ensureDir(dirname(absolute));
-    await writeJson(absolute, Object.fromEntries(getSortedRenameEntries(renameMap).map(([from, entry]) => [from, entry.newFilename])));
-    return absolute;
-}

package/dist/src/commands/pending-resolution.d.ts

@@ -1,15 +0,0 @@
-/**
- * Clears `pendingResolution` from `state.json` transactionally.
- *
- * Five commands (`doctor --clear-resolution`, `resolve`, `rebase --continue`,
- * `rebase --abort`, and the rebase patch loop) had each copied the same
- * spread-then-`delete` updater. The clear routes through `updateState` instead
- * of a load/modify/save pair so the updater runs inside the state-file lock
- * against the freshest on-disk state: a concurrent write to an unrelated key
- * (`buildMode`, `baseCommit`) is then not clobbered by a stale reload. Keeping
- * it in one place stops the copies from drifting apart.
- *
- * A no-op when nothing is pending, so callers need no guard of their own.
- * @param projectRoot - Project root holding `.fireforge/state.json`.
- */
-export declare function clearPendingResolution(projectRoot: string): Promise<void>;

package/dist/src/commands/pending-resolution.js

@@ -1,25 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { updateState } from '../core/config.js';
-/**
- * Clears `pendingResolution` from `state.json` transactionally.
- *
- * Five commands (`doctor --clear-resolution`, `resolve`, `rebase --continue`,
- * `rebase --abort`, and the rebase patch loop) had each copied the same
- * spread-then-`delete` updater. The clear routes through `updateState` instead
- * of a load/modify/save pair so the updater runs inside the state-file lock
- * against the freshest on-disk state: a concurrent write to an unrelated key
- * (`buildMode`, `baseCommit`) is then not clobbered by a stale reload. Keeping
- * it in one place stops the copies from drifting apart.
- *
- * A no-op when nothing is pending, so callers need no guard of their own.
- * @param projectRoot - Project root holding `.fireforge/state.json`.
- */
-export async function clearPendingResolution(projectRoot) {
-    await updateState(projectRoot, (current) => {
-        if (!current.pendingResolution)
-            return current;
-        const next = { ...current };
-        delete next.pendingResolution;
-        return next;
-    });
-}

package/dist/src/commands/re-export-adjacent-registrations.d.ts

@@ -1,20 +0,0 @@
-/** One changed engine file a registration line the patch adds names. */
-export interface RegisteredChangedFile {
-    /** Engine-relative path of the named file. */
-    file: string;
-    /** Engine-relative path of the carrier whose added line names it. */
-    carrier: string;
-}
-/**
- * Lists the changed (modified, deleted or untracked) engine files named by
- * the registration lines the patch's owned carriers add relative to HEAD.
- * Only added lines count: an upstream line naming an upstream file is not
- * the patch's registration. A wildcard token is matched against the changed
- * files under its carrier's directory, the only place such a token reaches
- * without the build system.
- *
- * @param engineDir - Engine checkout
- * @param ownedFiles - The patch's current filesAffected
- * @returns Named changed files, first carrier wins, sorted by path
- */
-export declare function findRegisteredChangedFiles(engineDir: string, ownedFiles: readonly string[]): Promise<RegisteredChangedFile[]>;