@hominis/fireforge 0.54.0 → 0.60.0

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

@@ -1,208 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge patch compact`: closes ordinal gaps in the patch queue.
- *
- * After deletes or splits, patch ordinals may have gaps (e.g. 1, 3, 7).
- * This command renumbers patches to close those gaps in a single atomic
- * operation, preserving relative order. Without a patch policy the whole
- * queue is renumbered from 1. With `patchPolicy.ranges` configured the
- * compaction is range-aware (each category range compacts independently,
- * reserved ranges and out-of-range strays are left untouched).
- */
-import { Command } from 'commander';
-import { loadConfig } from '../../core/config.js';
-import { confirmDestructive } from '../../core/destructive.js';
-import { appendHistoryBestEffort } from '../../core/history-log.js';
-import { withPatchDirectoryLock } from '../../core/patch-lock.js';
-import { loadPatchesManifest, renumberPatchesInManifest, } from '../../core/patch-manifest.js';
-import { applyRenameMapToManifest, enforcePatchPolicy } from '../../core/patch-policy.js';
-import { GeneralError } from '../../errors/base.js';
-import { info, intro, outro, warn } from '../../utils/logger.js';
-import { addWaitLockOption, pickDefined, resolveWaitLockSeconds } from '../../utils/options.js';
-import { proceedAfterDecision } from '../destructive-decision.js';
-import { renameMapsEqual } from '../patch-rename-map.js';
-import { requirePatchQueue } from './patch-context.js';
-import { rebuildFilenameForOrder } from './reorder-projection.js';
-/** True when `order` falls inside a configured reserved range. */
-function isReservedOrder(policyCfg, order) {
-    return (policyCfg.reservedRanges ?? []).some((r) => order >= r.from && order <= r.to);
-}
-/**
- * Computes a rename map that closes ordinal gaps.
- *
- * Without a patch policy, all patches are renumbered to 1, 2, 3, … in
- * current sort order (historical behaviour). With `patchPolicy.ranges`
- * configured, compaction happens within each category range instead:
- * each range's members are renumbered consecutively starting at the
- * range's first occupied ordinal, skipping reserved orders, mirroring
- * what `evaluateGaps` treats as gapless under `allowGaps: false`.
- * Reserved-range patches and patches outside their category's range are
- * never moved (a global renumber would project them across range
- * boundaries and trip `category-range` refusals).
- */
-function computeCompactRenameMap(patches, policyCfg) {
-    if (!policyCfg || policyCfg.ranges.length === 0) {
-        const sorted = [...patches].sort((a, b) => a.order - b.order);
-        const renames = new Map();
-        for (const [i, patch] of sorted.entries()) {
-            const newOrder = i + 1;
-            if (patch.order !== newOrder) {
-                renames.set(patch.filename, {
-                    newOrder,
-                    newFilename: rebuildFilenameForOrder(patch, newOrder),
-                });
-            }
-        }
-        return renames;
-    }
-    const renames = new Map();
-    for (const range of policyCfg.ranges) {
-        const members = patches
-            .filter((p) => p.category === range.category &&
-            p.order >= range.from &&
-            p.order <= range.to &&
-            !isReservedOrder(policyCfg, p.order))
-            .sort((a, b) => a.order - b.order || a.filename.localeCompare(b.filename));
-        if (members.length === 0)
-            continue;
-        // Anchor at the first occupied ordinal rather than range.from: gap
-        // evaluation only requires contiguity between first and last occupied,
-        // and anchoring minimizes renames.
-        let next = members[0].order;
-        for (const patch of members) {
-            while (isReservedOrder(policyCfg, next))
-                next++;
-            if (patch.order !== next) {
-                renames.set(patch.filename, {
-                    newOrder: next,
-                    newFilename: rebuildFilenameForOrder(patch, next),
-                });
-            }
-            next++;
-        }
-    }
-    return renames;
-}
-/**
- * Patches a range-aware compact leaves in place because they sit outside
- * their category's configured range (or outside all ranges) without a
- * reserved-range exception. They already violate `category-range`. Moving
- * them is a policy decision compact must not make silently.
- */
-function findCompactStrays(patches, policyCfg) {
-    return patches.filter((p) => {
-        if (isReservedOrder(policyCfg, p.order))
-            return false;
-        return !policyCfg.ranges.some((range) => range.category === p.category && p.order >= range.from && p.order <= range.to);
-    });
-}
-/**
- * Runs the `patch compact` command: renumbers all patches to close ordinal
- * gaps in a single atomic operation.
- *
- * @param projectRoot - Project root directory
- * @param options - Command options
- */
-export async function patchCompactCommand(projectRoot, options = {}) {
-    intro(options.dryRun ? 'FireForge patch compact (dry run)' : 'FireForge patch compact');
-    const config = await loadConfig(projectRoot);
-    const { paths, manifest } = await requirePatchQueue(projectRoot);
-    const policyCfg = config.patchPolicy;
-    if (policyCfg && policyCfg.ranges.length > 0) {
-        const strays = findCompactStrays(manifest.patches, policyCfg);
-        for (const stray of strays) {
-            warn(`${stray.filename} (order ${stray.order}, category ${stray.category}) sits outside its ` +
-                'configured category range; compact leaves it in place. Use "fireforge patch reorder" ' +
-                'to move it into range first.');
-        }
-    }
-    const renameMap = computeCompactRenameMap(manifest.patches, policyCfg);
-    if (renameMap.size === 0) {
-        info('Patch queue is already compact. Nothing to do.');
-        outro('Compact complete (no-op)');
-        return;
-    }
-    const sorted = [...renameMap.entries()].sort((a, b) => a[1].newOrder - b[1].newOrder);
-    const summary = [`${renameMap.size} patch(es) would be renumbered:`];
-    for (const [oldFilename, entry] of sorted) {
-        summary.push(`  ${oldFilename}  →  ${entry.newFilename}  (order ${entry.newOrder})`);
-    }
-    enforcePatchPolicy({
-        config,
-        manifest: applyRenameMapToManifest(manifest, renameMap),
-        command: 'patch compact',
-        forceUnsafe: options.forceUnsafe === true,
-    });
-    const decision = await confirmDestructive({
-        operation: 'patch-compact',
-        title: `Compact ${manifest.patches.length} patches (${renameMap.size} rename(s))`,
-        summary,
-        yes: options.yes === true,
-        dryRun: options.dryRun === true,
-        unsafeOverride: options.forceUnsafe === true,
-    });
-    if (!proceedAfterDecision(decision, 'Compact cancelled'))
-        return;
-    await withPatchDirectoryLock(paths.patches, async () => {
-        const currentManifest = await loadPatchesManifest(paths.patches);
-        if (!currentManifest) {
-            throw new GeneralError('Manifest disappeared while waiting for lock.');
-        }
-        const currentRenameMap = computeCompactRenameMap(currentManifest.patches, policyCfg);
-        if (currentRenameMap.size === 0) {
-            info('Patch queue was compacted by another process. Nothing to do.');
-            return;
-        }
-        // The operator confirmed a specific plan. A queue that changed between
-        // the prompt and the lock (an export landing a new patch, a delete)
-        // yields a different plan whose renames were never shown, so refuse
-        // rather than commit them under a history entry that says "ok". This
-        // is the same gate `patch reorder` applies.
-        if (!renameMapsEqual(renameMap, currentRenameMap)) {
-            throw new GeneralError('Patch queue changed while waiting for confirmation. Re-run compact to recompute the rename plan.');
-        }
-        enforcePatchPolicy({
-            config,
-            manifest: applyRenameMapToManifest(currentManifest, currentRenameMap),
-            command: 'patch compact',
-            forceUnsafe: options.forceUnsafe === true,
-        });
-        await renumberPatchesInManifest(paths.patches, currentRenameMap);
-        const historyEntry = {
-            operation: 'patch-compact',
-            args: {
-                renames: [...currentRenameMap.entries()]
-                    .sort((a, b) => a[1].newOrder - b[1].newOrder)
-                    .map(([from, entry]) => ({
-                    from,
-                    to: entry.newFilename,
-                    order: entry.newOrder,
-                })),
-            },
-            ...(options.yes === true ? { yes: true } : {}),
-            ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
-            result: 'ok',
-        };
-        await appendHistoryBestEffort(paths.patches, historyEntry, `patch compact committed`);
-    }, { waitLockSeconds: resolveWaitLockSeconds(options.waitLock), command: 'patch compact' });
-    info(`Compacted ${renameMap.size} patch(es).`);
-    outro('Compact complete');
-}
-/**
- * Registers the `patch compact` subcommand on the `patch` parent.
- *
- * @param parent - Parent Commander command
- * @param context - Shared CLI registration context
- */
-export function registerPatchCompact(parent, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const command = parent
-        .command('compact')
-        .description('Close ordinal gaps in the patch queue (range-aware when patchPolicy.ranges is configured)')
-        .option('--dry-run', 'Show what would happen without writing')
-        .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)')
-        .option('--force-unsafe', 'Bypass force-mode patchPolicy refusals');
-    addWaitLockOption(command).action(withErrorHandling(async (options) => {
-        await patchCompactCommand(getProjectRoot(), pickDefined(options));
-    }));
-}

package/dist/src/commands/patch/delete-gap-notice.d.ts

@@ -1,24 +0,0 @@
-/**
- * Projects the queue after a `patch delete` and names any numeric gap the
- * removal opens under `patchPolicy.allowGaps: false`.
- *
- * The delete itself succeeds either way; the gap only surfaces on the next
- * `lint --per-patch`, `re-export` or `verify`, which is the wrong moment to
- * learn that the queue needs a refill or a `patch compact`. Diffing the
- * policy evaluation of the current manifest against the projected one keeps
- * the arithmetic in `evaluatePatchPolicy`, so this module never re-derives
- * what counts as a gap.
- */
-import type { PatchesManifest, PatchMetadata } from '../../types/commands/index.js';
-import type { FireForgeConfig } from '../../types/config.js';
-/**
- * Describes each `numeric-gap` issue the queue would gain once `target` is
- * removed. Returns one operator-facing line per newly gapped range, or an
- * empty array when the policy allows gaps or the removal opens none (for
- * example deleting the last patch of a range).
- *
- * @param config - Loaded project configuration
- * @param manifest - Current patch manifest
- * @param target - Patch about to be deleted
- */
-export declare function describeProjectedGaps(config: FireForgeConfig, manifest: PatchesManifest, target: PatchMetadata): string[];

package/dist/src/commands/patch/delete-gap-notice.js

@@ -1,48 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Projects the queue after a `patch delete` and names any numeric gap the
- * removal opens under `patchPolicy.allowGaps: false`.
- *
- * The delete itself succeeds either way; the gap only surfaces on the next
- * `lint --per-patch`, `re-export` or `verify`, which is the wrong moment to
- * learn that the queue needs a refill or a `patch compact`. Diffing the
- * policy evaluation of the current manifest against the projected one keeps
- * the arithmetic in `evaluatePatchPolicy`, so this module never re-derives
- * what counts as a gap.
- */
-import { buildProjectedManifest, evaluatePatchPolicy } from '../../core/patch-policy.js';
-const GAP_MESSAGE_PATTERN = /^(?<range>.+?) has numeric gap\(s\): (?<orders>[^.]+)\./;
-/**
- * Describes each `numeric-gap` issue the queue would gain once `target` is
- * removed. Returns one operator-facing line per newly gapped range, or an
- * empty array when the policy allows gaps or the removal opens none (for
- * example deleting the last patch of a range).
- *
- * @param config - Loaded project configuration
- * @param manifest - Current patch manifest
- * @param target - Patch about to be deleted
- */
-export function describeProjectedGaps(config, manifest, target) {
-    if (config.patchPolicy?.allowGaps !== false)
-        return [];
-    const projected = buildProjectedManifest(manifest, manifest.patches.filter((patch) => patch.filename !== target.filename));
-    const gapKey = (issue) => `${issue.filename}|${issue.message}`;
-    const existing = new Set(evaluatePatchPolicy(config, manifest)
-        .filter((issue) => issue.code === 'numeric-gap')
-        .map(gapKey));
-    return evaluatePatchPolicy(config, projected)
-        .filter((issue) => issue.code === 'numeric-gap' && !existing.has(gapKey(issue)))
-        .map((issue) => formatGapNotice(target.filename, issue.message));
-}
-function formatGapNotice(targetFilename, message) {
-    const match = GAP_MESSAGE_PATTERN.exec(message);
-    const range = match?.groups?.['range'] ?? message;
-    const orders = match?.groups?.['orders'] ?? '';
-    const fill = orders.split(',')[0]?.trim() ?? '<n>';
-    const where = orders ? `a gap at ${orders}` : 'a numeric gap';
-    return (`deleting ${targetFilename} leaves ${range} with ${where}; the queue will fail ` +
-        'numeric-gap (patchPolicy.allowGaps is false) until ' +
-        `"fireforge export --order ${fill}" fills it or "fireforge patch compact" renumbers. ` +
-        `"fireforge patch retire ${targetFilename}" removes the patch and keeps its order as a ` +
-        'retired slot instead, so no gap opens.');
-}

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

@@ -1,28 +0,0 @@
-/**
- * `fireforge patch delete <name>`: removes a patch from the queue.
- *
- * Destructive: refuses when a later patch imports a module owned by the
- * target (that would leave a dangling forward import), prompts for
- * confirmation interactively, requires `--yes` for non-TTY, supports
- * `--dry-run`, and appends to the patch history log on success.
- */
-import { Command } from 'commander';
-import type { CommandContext } from '../../types/cli.js';
-import type { PatchDeleteOptions } from '../../types/commands/index.js';
-/**
- * Runs the `patch delete` command: removes a patch file and its manifest
- * row atomically, refusing when a later patch imports a leaf owned by the
- * target.
- *
- * @param projectRoot - Project root directory
- * @param identifier - Patch filename or ordinal number to delete
- * @param options - Command options
- */
-export declare function patchDeleteCommand(projectRoot: string, identifier: string, options?: PatchDeleteOptions): Promise<void>;
-/**
- * Registers the `patch delete` subcommand on the `patch` parent.
- *
- * @param parent - Parent Commander command
- * @param context - Shared CLI registration context
- */
-export declare function registerPatchDelete(parent: Command, context: CommandContext): void;

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

@@ -1,131 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge patch delete <name>`: removes a patch from the queue.
- *
- * Destructive: refuses when a later patch imports a module owned by the
- * target (that would leave a dangling forward import), prompts for
- * confirmation interactively, requires `--yes` for non-TTY, supports
- * `--dry-run`, and appends to the patch history log on success.
- */
-import { Command } from 'commander';
-import { loadConfig } from '../../core/config.js';
-import { confirmDestructive } from '../../core/destructive.js';
-import { appendHistoryBestEffort } from '../../core/history-log.js';
-import { buildPatchQueueContext } from '../../core/patch-lint.js';
-import { withPatchDirectoryLock } from '../../core/patch-lock.js';
-import { removePatchFileAndManifest } from '../../core/patch-manifest.js';
-import { GeneralError } from '../../errors/base.js';
-import { info, intro, outro, warn } from '../../utils/logger.js';
-import { addWaitLockOption, pickDefined, resolveWaitLockSeconds } from '../../utils/options.js';
-import { proceedAfterDecision } from '../destructive-decision.js';
-import { describeProjectedGaps } from './delete-gap-notice.js';
-import { requirePatchQueue, requirePatchTarget } from './patch-context.js';
-import { deleteCreatedFiles, planClaimedFiles, withCreatedFileLock, } from './removal-created-files.js';
-import { collectRemovalDependents, queueSnapshot, removalConflict, warnDanglingStagedOwners, } from './removal-dependents.js';
-/**
- * Runs the `patch delete` command: removes a patch file and its manifest
- * row atomically, refusing when a later patch imports a leaf owned by the
- * target.
- *
- * @param projectRoot - Project root directory
- * @param identifier - Patch filename or ordinal number to delete
- * @param options - Command options
- */
-export async function patchDeleteCommand(projectRoot, identifier, options = {}) {
-    intro(options.dryRun ? 'FireForge patch delete (dry run)' : 'FireForge patch delete');
-    const { paths, manifest } = await requirePatchQueue(projectRoot, {
-        missingDirMessage: 'Patches directory not found. No patches to delete.',
-    });
-    const target = requirePatchTarget(identifier, manifest.patches);
-    // Build the full queue context once so we can scan each patch's newFiles
-    // without re-parsing for the dependency check below. Hard refusal: an
-    // import owned by a later patch that points at any of the target's
-    // newly-created files is a dependency on the target.
-    const baseCtx = await buildPatchQueueContext(paths.patches);
-    const dependents = collectRemovalDependents(baseCtx, target, {
-        noun: 'deletion',
-        verb: 'delete',
-    });
-    warnDanglingStagedOwners(baseCtx, target, 'delete');
-    // Under `patchPolicy.allowGaps: false` the removal can open a numeric gap
-    // that every later lint and re-export refuses on. Naming it here, in
-    // dry-run and at the prompt, puts the refill/compact choice in front of
-    // the operator before the gap exists rather than after the next command.
-    const gapNotices = describeProjectedGaps(await loadConfig(projectRoot), manifest, target);
-    for (const line of gapNotices) {
-        warn(line);
-    }
-    const conflicts = removalConflict(dependents, target);
-    const claimed = await planClaimedFiles(baseCtx, target, paths.engine, options.deleteCreated === true);
-    const summary = [
-        `delete ${target.filename}  (category: ${target.category}, order: ${target.order})`,
-        `description: ${target.description || '(none)'}`,
-        ...claimed.summary,
-    ];
-    summary.push(...gapNotices);
-    const decision = await confirmDestructive({
-        operation: 'patch-delete',
-        title: `Delete ${target.filename}`,
-        summary,
-        yes: options.yes === true,
-        dryRun: options.dryRun === true,
-        unsafeOverride: options.forceUnsafe === true,
-        conflicts,
-    });
-    if (!proceedAfterDecision(decision, 'Delete cancelled'))
-        return;
-    // Proceed: remove under the patch directory lock so concurrent exports
-    // cannot race us into the same manifest row. The history append lives
-    // inside the same lock so two concurrent deletes cannot interleave history
-    // records beyond what POSIX O_APPEND guarantees for a single record, and
-    // so a crash between mutation and history write cannot leave a committed
-    // mutation with no audit trail. A history append failure is warned but not
-    // re-thrown: by that point the mutation has committed, and reporting
-    // failure to the caller would mislead.
-    const waitLockSeconds = resolveWaitLockSeconds(options.waitLock);
-    await withCreatedFileLock(projectRoot, 'patch delete', claimed, waitLockSeconds, () => withPatchDirectoryLock(paths.patches, async () => {
-        const current = await buildPatchQueueContext(paths.patches);
-        // A changed body or manifest invalidates the dependency scan approved
-        // before the prompt. Recheck all of its inputs while holding the lock.
-        if (queueSnapshot(current) !== queueSnapshot(baseCtx)) {
-            throw new GeneralError('Patch queue changed while waiting for confirmation or the lock. Re-run patch delete to review the current dependencies.');
-        }
-        await removePatchFileAndManifest(paths.patches, target.filename);
-        await deleteCreatedFiles(paths.engine, claimed.deleteOnCommit);
-        await appendHistoryBestEffort(paths.patches, {
-            operation: 'patch-delete',
-            args: {
-                filename: target.filename,
-                order: target.order,
-                filesAffected: target.filesAffected,
-                ...(claimed.deleteOnCommit.length > 0
-                    ? { deletedCreatedFiles: claimed.deleteOnCommit }
-                    : {}),
-            },
-            ...(options.yes === true ? { yes: true } : {}),
-            ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
-            result: 'ok',
-        }, `patch delete committed (${target.filename})`);
-    }, { waitLockSeconds, command: 'patch delete' }));
-    info(`Deleted ${target.filename}.`);
-    outro('Delete complete');
-}
-/**
- * Registers the `patch delete` subcommand on the `patch` parent.
- *
- * @param parent - Parent Commander command
- * @param context - Shared CLI registration context
- */
-export function registerPatchDelete(parent, context) {
-    const { getProjectRoot, withErrorHandling } = context;
-    const command = parent
-        .command('delete <name>')
-        .description('Delete a patch from the queue (destructive)')
-        .option('--dry-run', 'Show what would happen without writing')
-        .option('-y, --yes', 'Skip confirmation prompt (required for non-TTY)')
-        .option('--delete-created', 'Also delete the engine files this patch creates that are still on disk, instead of leaving them unmanaged')
-        .option('--force-unsafe', 'Bypass the refusal when a later patch depends on this patch (last resort)');
-    addWaitLockOption(command).action(withErrorHandling(async (name, options) => {
-        await patchDeleteCommand(getProjectRoot(), name, pickDefined(options));
-    }));
-}

package/dist/src/commands/patch/entry-projection.d.ts

@@ -1,13 +0,0 @@
-import type { PatchQueueEntry } from '../../core/patch-lint.js';
-/**
- * Projects a rewritten patch body into the three fields cross-patch lint reads
- * off a queue entry.
- *
- * `patch split` and `patch move-files` each had a byte-identical copy of this
- * (`buildEntryProjection` / `projectEntryBody`). Both feed the same linter, so
- * a change to what the projection carries has to reach both or the two
- * commands start refusing different things for the same queue.
- * @param diff - The rewritten patch body.
- * @returns The diff plus its derived new-file and modified-file projections.
- */
-export declare function projectEntryBody(diff: string): Pick<PatchQueueEntry, 'diff' | 'newFiles' | 'createdFiles' | 'modifiedFileAdditions'>;

package/dist/src/commands/patch/entry-projection.js

@@ -1,24 +0,0 @@
-import { buildModifiedFileAdditionsFromDiff } from '../../core/patch-lint.js';
-import { detectNewFilesInDiff } from '../../core/patch-lint-diff.js';
-import { buildNewFileTextProjection } from '../../core/patch-transform.js';
-/**
- * Projects a rewritten patch body into the three fields cross-patch lint reads
- * off a queue entry.
- *
- * `patch split` and `patch move-files` each had a byte-identical copy of this
- * (`buildEntryProjection` / `projectEntryBody`). Both feed the same linter, so
- * a change to what the projection carries has to reach both or the two
- * commands start refusing different things for the same queue.
- * @param diff - The rewritten patch body.
- * @returns The diff plus its derived new-file and modified-file projections.
- */
-export function projectEntryBody(diff) {
-    const newFiles = buildNewFileTextProjection(diff);
-    return {
-        diff,
-        newFiles,
-        // Body-kind agnostic: a binary creation is still a creation.
-        createdFiles: detectNewFilesInDiff(diff),
-        modifiedFileAdditions: buildModifiedFileAdditionsFromDiff(diff),
-    };
-}

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

@@ -1,16 +0,0 @@
-/**
- * `fireforge patch <verb>` parent command. Groups single-patch mutations and
- * planners (`compact`, `delete`, `lint-ignore`, `move-files`, `rename`,
- * `reorder`, `reserve`, `retire`, `split`, `stage`, `staged-dependency`,
- * `tier`) so they do not clutter the top-level command list. Queue-level
- * verbs like `lint`, `export`, `verify`, and `status` stay flat.
- */
-import { Command } from 'commander';
-import type { CommandContext } from '../../types/cli.js';
-/**
- * Registers the `patch` subcommand parent and its verbs on the CLI.
- *
- * @param program - Commander root program
- * @param context - Shared CLI registration context
- */
-export declare function registerPatch(program: Command, context: CommandContext): void;

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

@@ -1,52 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `fireforge patch <verb>` parent command. Groups single-patch mutations and
- * planners (`compact`, `delete`, `lint-ignore`, `move-files`, `rename`,
- * `reorder`, `reserve`, `retire`, `split`, `stage`, `staged-dependency`,
- * `tier`) so they do not clutter the top-level command list. Queue-level
- * verbs like `lint`, `export`, `verify`, and `status` stay flat.
- */
-import { Command } from 'commander';
-import { registerPatchCompact } from './compact.js';
-import { registerPatchDelete } from './delete.js';
-import { registerPatchLintIgnore } from './lint-ignore.js';
-import { registerPatchMoveFiles } from './move-files.js';
-import { registerPatchRename } from './rename.js';
-import { registerPatchReorder } from './reorder.js';
-import { registerPatchReserve } from './reserve.js';
-import { registerPatchRetire } from './retire.js';
-import { registerPatchSplit } from './split.js';
-import { registerPatchStage } from './stage.js';
-import { registerPatchStagedDependency } from './staged-dependency.js';
-import { registerPatchTier } from './tier.js';
-/**
- * Registers the `patch` subcommand parent and its verbs on the CLI.
- *
- * @param program - Commander root program
- * @param context - Shared CLI registration context
- */
-export function registerPatch(program, context) {
-    const patch = program
-        .command('patch')
-        .description('Manage individual patches in the queue (compact, delete, lint-ignore, move-files, rename, reorder, reserve, retire, split, stage, staged-dependency, tier)')
-        // Match `fireforge furnace`'s no-args contract: print the group's help
-        // and exit 0. Without this default action, commander routes
-        // `fireforge patch` (no subcommand) through its own help-then-exit-1
-        // path, so scripts probing the CLI surface see a misleading non-zero
-        // exit for a purely informational invocation.
-        .action(() => {
-        patch.outputHelp();
-    });
-    registerPatchCompact(patch, context);
-    registerPatchDelete(patch, context);
-    registerPatchLintIgnore(patch, context);
-    registerPatchMoveFiles(patch, context);
-    registerPatchRename(patch, context);
-    registerPatchReorder(patch, context);
-    registerPatchReserve(patch, context);
-    registerPatchRetire(patch, context);
-    registerPatchSplit(patch, context);
-    registerPatchStage(patch, context);
-    registerPatchStagedDependency(patch, context);
-    registerPatchTier(patch, context);
-}

package/dist/src/commands/patch/lint-ignore-from.d.ts

@@ -1,43 +0,0 @@
-/**
- * Batch and per-entry input for `patch lint-ignore --add`. Split out of
- * `lint-ignore.ts` for the per-file line budget.
- *
- * `--max` applies to every `--add` of a call, so a rebaseline that sets a
- * ceiling per rule would take one call per rule, each taking the patch lock
- * and rewriting `patches.json`. Two forms avoid that:
- *
- * - `--add <rule>=<max>` gives each entry its own ceiling in one call.
- * - `--from <json-file>` reads every entry from a file, under one lock hold
- *   and one write. The file is a JSON array of entries (a check ID string,
- *   or `{ rule, max, reason?, share?, meta?, patch? }`), or a
- *   `lint --per-patch --report` document, whose `lintIgnoreCeilings` rows
- *   for the target patch are rebaselined to their current measurement.
- */
-import type { LintIgnoreEntry, PatchLintIgnoreOptions, PatchSizeShare } from '../../types/commands/index.js';
-/**
- * Turns `--add` values into entries: `<rule>=<max>` is a ceiling at `max`,
- * a bare ID is a ceiling at `--max` when that is given and a bare waiver
- * otherwise. Every ceiling takes `--reason` (required) and `--share`.
- *
- * @param ids - The `--add` values
- * @param options - Command options (`max`, `reason`, `share`)
- * @returns The entries to upsert
- */
-export declare function resolveAddEntries(ids: readonly string[], options: Pick<PatchLintIgnoreOptions, 'max' | 'reason' | 'share'>): LintIgnoreEntry[];
-/** Entries read from a `--from` file for one target patch. */
-export interface LintIgnoreBatch {
-    entries: LintIgnoreEntry[];
-    /** Entries naming a different patch, left out. */
-    skippedForOtherPatches: number;
-}
-/**
- * Reads a `--from` file into entries for `targetFilename`.
- *
- * @param path - JSON file path
- * @param targetFilename - The patch the command edits
- * @param defaultReason - `--reason`, used for object entries without one
- * @returns The validated entries and the count left out for other patches
- */
-export declare function readLintIgnoreBatch(path: string, targetFilename: string, defaultReason: string | undefined): Promise<LintIgnoreBatch>;
-/** Parses `--share`. */
-export declare function parseShare(value: string): PatchSizeShare;