@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/commands/re-export-retired-declarations.js

@@ -1,113 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * `re-export --expect-removed` drops the staged declarations whose
- * `creates` path the run retires.
- *
- * Retiring a file would otherwise leave another patch's staged
- * registration (or forward import) for it in place, unflagged until the
- * per-patch lint after both re-exports reported `staged-dependency-unused`.
- * The run that retires the path drops every such declaration, in any patch of the queue, in one manifest
- * update, and names each one.
- */
-import { withPatchDirectoryLock } from '../core/patch-lock.js';
-import { loadPatchesManifestForWrite, mutatePatchRowsInManifest } from '../core/patch-manifest.js';
-import { info } from '../utils/logger.js';
-import { recordStagedDeclarationPrune, } from './re-export-stale-registrations.js';
-/**
- * Finds the declarations whose `creates` path is retired and owned by no
- * patch outside `retiring`.
- *
- * @param manifest - The queue to judge
- * @param removed - The run's `--expect-removed` paths
- * @param retiring - Patches whose ownership of a removed path does not
- *   count: the selected owners in a dry run, whose rows are not rewritten
- *   yet; nothing after the write, where a failed owner still owns its path
- */
-function planRetiredDeclarationDrops(manifest, removed, retiring) {
-    const orphaned = new Set(removed.filter((file) => !manifest.patches.some((patch) => !retiring.has(patch.filename) && patch.filesAffected.includes(file))));
-    if (orphaned.size === 0)
-        return [];
-    const drops = [];
-    for (const patch of manifest.patches) {
-        const drop = planHolderDrop(patch, orphaned);
-        if (drop !== undefined)
-            drops.push(drop);
-    }
-    return drops;
-}
-function planHolderDrop(patch, orphaned) {
-    const forwardImports = patch.stagedDependencies?.forwardImports ?? [];
-    const registrations = patch.stagedDependencies?.registrations ?? [];
-    const dropped = [
-        ...registrations
-            .filter((entry) => orphaned.has(entry.creates))
-            .map((entry) => ({ kind: 'registration', ...entry })),
-        ...forwardImports
-            .filter((entry) => orphaned.has(entry.creates))
-            .map((entry) => ({ kind: 'import', ...entry })),
-    ];
-    if (dropped.length === 0)
-        return undefined;
-    const keptImports = forwardImports.filter((entry) => !orphaned.has(entry.creates));
-    const keptRegistrations = registrations.filter((entry) => !orphaned.has(entry.creates));
-    const staged = {
-        ...(keptImports.length > 0 ? { forwardImports: keptImports } : {}),
-        ...(keptRegistrations.length > 0 ? { registrations: keptRegistrations } : {}),
-    };
-    return {
-        holder: patch.filename,
-        dropped,
-        stagedDependencies: Object.keys(staged).length > 0 ? staged : undefined,
-    };
-}
-function reportRetiredDeclarationDrops(drops, isDryRun) {
-    const verb = isDryRun ? 'would drop' : 'drops';
-    for (const { holder, dropped } of drops) {
-        for (const entry of dropped) {
-            const what = entry.kind === 'registration'
-                ? `staged registration ${entry.file} "${entry.line.trim()}"`
-                : `staged forward-import ${entry.file} "${entry.specifier}"`;
-            info(`${holder}: ${verb} ${what}: --expect-removed retires ${entry.creates}.`);
-        }
-    }
-}
-/**
- * Drops (or, in a dry run, names) every staged declaration whose `creates`
- * path this run retired. Runs after the selected patches are written, so a
- * path whose owner failed to re-export is still owned and its declarations
- * stay.
- */
-export async function dropRetiredPathDeclarations(args) {
-    const { manifest, isDryRun } = args;
-    const patchesDir = args.paths.patches;
-    const removed = args.options.expectRemoved ?? [];
-    const selected = new Set(args.selectedPatches.map((patch) => patch.filename));
-    if (removed.length === 0)
-        return;
-    if (isDryRun) {
-        reportRetiredDeclarationDrops(planRetiredDeclarationDrops(manifest, removed, selected), isDryRun);
-        return;
-    }
-    const drops = await withPatchDirectoryLock(patchesDir, async () => {
-        const current = await loadPatchesManifestForWrite(patchesDir);
-        if (!current)
-            return [];
-        const planned = planRetiredDeclarationDrops(current, removed, new Set());
-        const byHolder = new Map(planned.map((drop) => [drop.holder, drop]));
-        if (byHolder.size === 0)
-            return [];
-        await mutatePatchRowsInManifest(patchesDir, [...byHolder.keys()], (existing) => {
-            const drop = byHolder.get(existing.filename);
-            if (drop === undefined)
-                return null;
-            return drop.stagedDependencies === undefined
-                ? { unset: ['stagedDependencies'] }
-                : { set: { stagedDependencies: drop.stagedDependencies } };
-        });
-        return planned;
-    }, { command: 're-export' });
-    reportRetiredDeclarationDrops(drops, isDryRun);
-    for (const drop of drops) {
-        await recordStagedDeclarationPrune(patchesDir, drop.holder, drop.dropped, 'staged declarations on retired paths');
-    }
-}

package/dist/src/commands/re-export-scan-owner.d.ts

@@ -1,44 +0,0 @@
-/**
- * Per-file owners for `re-export --scan --scan-file <patch>:<path>`.
- *
- * One change often spans a patch that creates files and a patch that
- * registers or imports them. With `--scan-file` bound to a single target
- * patch, that change took two invocations, and the adopting one could not
- * carry the belts the other did. Naming the owner per file lets one call
- * adopt each file into its patch while every other selected patch
- * refreshes scan-less, all under the same `--refuse-foreign-drift` belt
- * and in a single engine-lock hold.
- */
-import type { PatchesManifest, PatchMetadata, ReExportOptions } from '../types/commands/index.js';
-/** A `--scan-file` value split into its optional owner and its path. */
-export interface ScanFileOwnerSpec {
-    owner: string | undefined;
-    path: string;
-}
-/**
- * Splits `<patch>:<path>` into owner and path. The owner is everything
- * before the first `:`, and only when that part holds no path separator, so
- * a plain path (even one with a later `:`) stays a path. A one-letter
- * prefix before `:/` or `:\` reads as a Windows drive, not a patch.
- */
-export declare function splitScanFileOwner(raw: string): ScanFileOwnerSpec;
-/** Rejoins a split value, so normalization can rewrite the path half only. */
-export declare function joinScanFileOwner(spec: ScanFileOwnerSpec): string;
-/**
- * Argument-shape check, before any manifest is read: a multi-patch call has
- * to say which patch each file joins.
- */
-export declare function validateScanFileOwners(patches: readonly string[], scanFiles: readonly string[]): void;
-/**
- * Resolves each `--scan-file` value to its owning selected patch. Returns
- * `undefined` when no `--scan-file` was given. An unprefixed path belongs
- * to the single selected patch (the historical form).
- */
-export declare function assignScanFileOwners(scanFiles: readonly string[] | undefined, selectedPatches: readonly PatchMetadata[], manifest: PatchesManifest): Map<string, string[]> | undefined;
-/**
- * The options one patch of the loop runs with. A patch with assigned files
- * adopts exactly those; a selected patch without any refreshes scan-less,
- * because `--scan` beside per-file owners scopes adoption to the named
- * files rather than arming a broad directory scan for every other patch.
- */
-export declare function scanOptionsForPatch(options: ReExportOptions, patchFilename: string, assignments: ReadonlyMap<string, string[]> | undefined): ReExportOptions;

package/dist/src/commands/re-export-scan-owner.js

@@ -1,116 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Per-file owners for `re-export --scan --scan-file <patch>:<path>`.
- *
- * One change often spans a patch that creates files and a patch that
- * registers or imports them. With `--scan-file` bound to a single target
- * patch, that change took two invocations, and the adopting one could not
- * carry the belts the other did. Naming the owner per file lets one call
- * adopt each file into its patch while every other selected patch
- * refreshes scan-less, all under the same `--refuse-foreign-drift` belt
- * and in a single engine-lock hold.
- */
-import { formatPatchNotFoundError } from '../core/patch-identifier-suggest.js';
-import { resolvePatchIdentifier } from '../core/patch-manifest.js';
-import { InvalidArgumentError } from '../errors/base.js';
-/**
- * Splits `<patch>:<path>` into owner and path. The owner is everything
- * before the first `:`, and only when that part holds no path separator, so
- * a plain path (even one with a later `:`) stays a path. A one-letter
- * prefix before `:/` or `:\` reads as a Windows drive, not a patch.
- */
-export function splitScanFileOwner(raw) {
-    const colon = raw.indexOf(':');
-    if (colon <= 0)
-        return { owner: undefined, path: raw };
-    const owner = raw.slice(0, colon).trim();
-    const path = raw.slice(colon + 1);
-    if (owner.length === 0 || /[/\\]/.test(owner))
-        return { owner: undefined, path: raw };
-    if (/^[A-Za-z]$/.test(owner) && /^[/\\]/.test(path))
-        return { owner: undefined, path: raw };
-    return { owner, path };
-}
-/** Rejoins a split value, so normalization can rewrite the path half only. */
-export function joinScanFileOwner(spec) {
-    return spec.owner === undefined ? spec.path : `${spec.owner}:${spec.path}`;
-}
-/**
- * Argument-shape check, before any manifest is read: a multi-patch call has
- * to say which patch each file joins.
- */
-export function validateScanFileOwners(patches, scanFiles) {
-    if (patches.length === 0) {
-        throw new InvalidArgumentError('--scan-file needs explicit target patch identifiers.', '--scan-file');
-    }
-    if (patches.length === 1)
-        return;
-    const unowned = scanFiles.filter((file) => splitScanFileOwner(file).owner === undefined);
-    if (unowned.length > 0) {
-        throw new InvalidArgumentError(`--scan-file in a call with ${patches.length} patches must name each file's owning patch ` +
-            `as <patch>:<path> (for example --scan-file ${patches[0] ?? '201'}:${unowned[0] ?? '<path>'}). ` +
-            `Missing an owner: ${unowned.join(', ')}.`, '--scan-file');
-    }
-}
-/**
- * Resolves each `--scan-file` value to its owning selected patch. Returns
- * `undefined` when no `--scan-file` was given. An unprefixed path belongs
- * to the single selected patch (the historical form).
- */
-export function assignScanFileOwners(scanFiles, selectedPatches, manifest) {
-    if (scanFiles === undefined)
-        return undefined;
-    const selected = new Set(selectedPatches.map((patch) => patch.filename));
-    const byPatch = new Map();
-    const ownerByFile = new Map();
-    for (const raw of scanFiles) {
-        const { owner, path } = splitScanFileOwner(raw);
-        const filename = resolveOwner(owner, selectedPatches, manifest);
-        if (!selected.has(filename)) {
-            throw new InvalidArgumentError(`--scan-file ${raw}: ${filename} is not among the selected patches. ` +
-                'Pass it as a positional patch too.', '--scan-file');
-        }
-        const previous = ownerByFile.get(path);
-        if (previous !== undefined && previous !== filename) {
-            throw new InvalidArgumentError(`--scan-file path is assigned to more than one patch: ${path} (${previous}, ${filename})`, '--scan-file');
-        }
-        ownerByFile.set(path, filename);
-        const files = byPatch.get(filename) ?? [];
-        if (!files.includes(path))
-            files.push(path);
-        byPatch.set(filename, files);
-    }
-    for (const files of byPatch.values())
-        files.sort();
-    return byPatch;
-}
-function resolveOwner(owner, selectedPatches, manifest) {
-    if (owner === undefined) {
-        const only = selectedPatches.length === 1 ? selectedPatches[0] : undefined;
-        if (only === undefined) {
-            throw new InvalidArgumentError('--scan-file in a multi-patch call must name its owning patch as <patch>:<path>.', '--scan-file');
-        }
-        return only.filename;
-    }
-    const match = resolvePatchIdentifier(owner, manifest.patches);
-    if (!match) {
-        throw new InvalidArgumentError(`--scan-file: ${formatPatchNotFoundError(owner, manifest.patches)}`, '--scan-file');
-    }
-    return match.filename;
-}
-/**
- * The options one patch of the loop runs with. A patch with assigned files
- * adopts exactly those; a selected patch without any refreshes scan-less,
- * because `--scan` beside per-file owners scopes adoption to the named
- * files rather than arming a broad directory scan for every other patch.
- */
-export function scanOptionsForPatch(options, patchFilename, assignments) {
-    if (assignments === undefined)
-        return options;
-    const assigned = assignments.get(patchFilename);
-    if (assigned !== undefined)
-        return { ...options, scanFiles: assigned };
-    const scanLess = { ...options, scan: false };
-    delete scanLess.scanFiles;
-    return scanLess;
-}

package/dist/src/commands/re-export-scan.d.ts

@@ -1,72 +0,0 @@
-import { type PatchQueueContext } from '../core/patch-lint.js';
-import type { PatchesManifest } from '../types/commands/index.js';
-import type { FireForgeConfig } from '../types/config.js';
-export interface ScanResult {
-    updated: string[];
-    added: string[];
-    removed: string[];
-}
-/**
- * Normalizes repeatable `--scan-file` inputs into safe engine-relative
- * paths, keeping an optional `<patch>:` owner prefix intact.
- */
-export declare function normalizeScanFiles(scanFiles: readonly string[] | undefined): string[] | undefined;
-/** Normalizes one CLI-provided path into a safe engine-relative path. */
-export declare function normalizeEngineRelativeInput(rawPath: string, flagName: string): string;
-/** Scans either broad sibling directories or explicit `--scan-file` paths for re-export. */
-export declare function scanPatchFilesForReExport(args: {
-    currentFilesAffected: string[];
-    engineDir: string;
-    manifest: PatchesManifest;
-    patchFilename: string;
-    isDryRun: boolean;
-    scanFiles?: readonly string[];
-}): Promise<ScanResult>;
-/**
- * Confirms broad directory-scan additions before a mutating re-export writes
- * them into patch ownership.
- */
-export declare function confirmBroadScanAdditions(args: {
-    patchFilename: string;
-    added: readonly string[];
-    isDryRun: boolean;
-    yes: boolean;
-    isInteractive: boolean;
-}): Promise<boolean>;
-/**
- * Refuses scan adoptions whose candidate files import modules created by
- * later patches. Modeled on the `re-export --files` cross-patch
- * projection: the candidates' diffs are projected into the adopting
- * patch's queue entry, the queue lint runs baseline vs projection, and
- * only forward-import regressions attributable to the candidates block.
- * Staged-dependency declarations and inline lint-ignore markers are
- * honored automatically because the real lint rule evaluates them.
- * Covers broad `--scan`, `--scan-file`, and the `--scan-files` bulk flow
- * (all adopt through the same scan result), including dry-run.
- */
-export declare function assertScanAdoptionsHaveNoForwardImports(args: {
-    patchesDir: string;
-    engineDir: string;
-    patchFilename: string;
-    added: readonly string[];
-    /**
-     * Threads `patchLint.forwardRegistration` so jar.mn registrations are judged
-     * too, and `patchPolicy`, so the remedy names a legal order.
-     */
-    config?: FireForgeConfig;
-    /** `--declarations-out`: where the one `--from`-ready report goes. */
-    declarationsOut?: string | undefined;
-}): Promise<void>;
-/** The manifest rows a queue context carries, for remedy computations. */
-export declare function manifestFromQueue(ctx: PatchQueueContext): PatchesManifest;
-/** `{ category }` of the named queue entry, or `{}` when it has no metadata. */
-export declare function categoryOf(ctx: PatchQueueContext, filename: string): {
-    category?: string;
-};
-/** Refuses explicit `--scan-file` additions that did not produce patch hunks. */
-export declare function assertScanFileAdditionsHaveDiffHunks(args: {
-    diffContent: string;
-    patchFilename: string;
-    previousFilesAffected: readonly string[];
-    scanFiles: readonly string[] | undefined;
-}): void;

package/dist/src/commands/re-export-scan.js

@@ -1,265 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-import { dirname, join, resolve } from 'node:path';
-import { confirm } from '@clack/prompts';
-import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
-import { listTrackedInHead } from '../core/git-file-ops.js';
-import { getModifiedFilesInDir, getUntrackedFilesInDir } from '../core/git-status.js';
-import { extractAffectedFiles } from '../core/patch-apply.js';
-import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, lintPatchQueue, } from '../core/patch-lint.js';
-import { detectNewFilesInDiff } from '../core/patch-lint-diff.js';
-import { computeProjectedLintRegressions } from '../core/patch-lint-projection.js';
-import { getClaimedFiles } from '../core/patch-manifest.js';
-import { buildNewFileTextProjection } from '../core/patch-transform.js';
-import { GeneralError, InvalidArgumentError } from '../errors/base.js';
-import { mapWithConcurrency } from '../utils/concurrency.js';
-import { pathExists } from '../utils/fs.js';
-import { cancel, info, isCancel, warn } from '../utils/logger.js';
-import { isContainedRelativePath, normalizePathSlashes, stripEnginePrefix, } from '../utils/paths.js';
-import { formatDeclarationsReport, writeDeclarationsReport } from './declarations-report.js';
-import { formatForwardImportRemedy } from './forward-import-remedy.js';
-import { joinScanFileOwner, splitScanFileOwner } from './re-export-scan-owner.js';
-const SCAN_ADD_COUNT_THRESHOLD = 3;
-/** Concurrency bound for existence probes (matches the classify/lint pools). */
-const PATH_PROBE_CONCURRENCY = 8;
-const SCAN_DIR_COUNT_THRESHOLD = 2;
-/**
- * Normalizes repeatable `--scan-file` inputs into safe engine-relative
- * paths, keeping an optional `<patch>:` owner prefix intact.
- */
-export function normalizeScanFiles(scanFiles) {
-    const normalized = [
-        ...new Set((scanFiles ?? []).map((file) => {
-            const spec = splitScanFileOwner(file);
-            return joinScanFileOwner({
-                owner: spec.owner,
-                path: normalizeEngineRelativeInput(spec.path, '--scan-file'),
-            });
-        })),
-    ].sort();
-    return normalized.length > 0 ? normalized : undefined;
-}
-/** Normalizes one CLI-provided path into a safe engine-relative path. */
-export function normalizeEngineRelativeInput(rawPath, flagName) {
-    const normalized = normalizePathSlashes(stripEnginePrefix(rawPath).trim());
-    if (normalized.length === 0) {
-        throw new InvalidArgumentError(`${flagName} requires a non-empty engine-relative path.`, flagName);
-    }
-    if (!isContainedRelativePath(normalized)) {
-        throw new InvalidArgumentError(`${flagName} path must stay within engine/: ${rawPath}`, flagName);
-    }
-    return normalized;
-}
-/** Scans either broad sibling directories or explicit `--scan-file` paths for re-export. */
-export async function scanPatchFilesForReExport(args) {
-    const { scanFiles } = args;
-    if (scanFiles !== undefined) {
-        return scanPatchFilesTargeted({ ...args, scanFiles });
-    }
-    return scanPatchFiles(args);
-}
-async function scanPatchFiles(args) {
-    const { currentFilesAffected, engineDir, manifest, patchFilename, isDryRun } = args;
-    const parentDirs = [...new Set(currentFilesAffected.map((f) => dirname(f)))];
-    const claimedByOthers = getClaimedFiles(manifest, patchFilename);
-    const discoveredFiles = new Set();
-    for (const dir of parentDirs) {
-        const modifiedFiles = await getModifiedFilesInDir(engineDir, dir);
-        const untrackedFiles = await getUntrackedFilesInDir(engineDir, dir);
-        for (const f of [...modifiedFiles, ...untrackedFiles])
-            discoveredFiles.add(f);
-    }
-    // Git pathspecs recurse, so a claimed file in a shallow directory would
-    // sweep entire subtrees into the candidate set: with several patches
-    // sharing a parent directory, every unmanaged file in the tree gets
-    // offered to whichever patch is scanned first. Constrain the broad scan
-    // to the patch's exact directory footprint. Deeper paths need an
-    // explicit --scan-file / --scan-files assignment.
-    const parentDirSet = new Set(parentDirs);
-    const currentSet = new Set(currentFilesAffected);
-    const added = [...discoveredFiles]
-        .filter((f) => parentDirSet.has(dirname(f)) && !currentSet.has(f) && !claimedByOthers.has(f))
-        .sort();
-    const removed = await findRemovedFiles(currentFilesAffected, engineDir);
-    return reportScanResult(currentFilesAffected, patchFilename, isDryRun, added, removed);
-}
-async function scanPatchFilesTargeted(args) {
-    const { currentFilesAffected, engineDir, manifest, patchFilename, isDryRun, scanFiles } = args;
-    const currentSet = new Set(currentFilesAffected);
-    const claimedByOthers = getClaimedFiles(manifest, patchFilename);
-    const added = [];
-    // Phase-split for bounded concurrency: the sync claimed-by-others check
-    // first (first offender in argument order, as before), then pooled
-    // existence probes with the refusal chosen by ordered iteration so the
-    // first missing file in argument order is named deterministically.
-    for (const file of scanFiles) {
-        if (claimedByOthers.has(file)) {
-            throw new InvalidArgumentError(`--scan-file path is already claimed by another patch: ${file}`, '--scan-file');
-        }
-    }
-    const exists = await mapWithConcurrency(scanFiles, PATH_PROBE_CONCURRENCY, (file) => pathExists(join(engineDir, file)));
-    for (const [index, file] of scanFiles.entries()) {
-        if (exists[index] !== true) {
-            throw new InvalidArgumentError(`--scan-file path not found in engine/: ${file}. ` +
-                '--scan-file brings a path INTO patch ownership, which needs content to diff. ' +
-                'If the path was deleted and the patch already owns it, a plain re-export now ' +
-                'captures the deletion — no scan flag is needed.', '--scan-file');
-        }
-        if (!currentSet.has(file))
-            added.push(file);
-    }
-    const removed = await findRemovedFiles(currentFilesAffected, engineDir);
-    return reportScanResult(currentFilesAffected, patchFilename, isDryRun, added.sort(), removed);
-}
-/**
- * Paths that have genuinely left the patch's ownership: absent from disk and
- * untracked in engine HEAD.
- *
- * An absent path that is tracked in HEAD is a deletion, not a de-ownership.
- * The diff carries it as a `deleted file mode` section, so it must stay in
- * `filesAffected`. Pruning it desynchronises the manifest from the patch
- * body in the direction that hurts: the body says "delete this file", the
- * file list says the patch has nothing to do with it.
- */
-async function findRemovedFiles(files, engineDir) {
-    const exists = await mapWithConcurrency(files, PATH_PROBE_CONCURRENCY, (file) => pathExists(join(engineDir, file)));
-    const absent = files.filter((_, index) => exists[index] !== true);
-    const trackedAbsent = await listTrackedInHead(engineDir, absent);
-    return absent.filter((file) => !trackedAbsent.has(file)).sort();
-}
-function reportScanResult(currentFilesAffected, patchFilename, isDryRun, added, removed) {
-    for (const f of added)
-        info(`  + ${f}`);
-    for (const f of removed)
-        info(`  - ${f}`);
-    if (added.length === 0 && removed.length === 0) {
-        return { updated: currentFilesAffected, added: [], removed: [] };
-    }
-    const removedSet = new Set(removed);
-    const updated = [...currentFilesAffected.filter((f) => !removedSet.has(f)), ...added].sort();
-    info(`  ${isDryRun ? 'Would update' : 'Updated'} ${patchFilename}: +${added.length} / -${removed.length} files`);
-    return { updated, added, removed };
-}
-/**
- * Confirms broad directory-scan additions before a mutating re-export writes
- * them into patch ownership.
- */
-export async function confirmBroadScanAdditions(args) {
-    const { patchFilename, added, isDryRun, yes, isInteractive } = args;
-    if (isDryRun || yes || !scanAdditionsNeedConfirmation(added))
-        return true;
-    const dirCount = new Set(added.map((f) => dirname(f))).size;
-    warn(`${patchFilename}: --scan would add ${added.length} file(s) that span ${dirCount} director${dirCount === 1 ? 'y' : 'ies'}. ` +
-        'Broad scans can silently pull adjacent features into a patch — review the diff before continuing.');
-    if (!isInteractive) {
-        throw new GeneralError(`Refusing to broaden "${patchFilename}" via --scan in non-interactive mode. ` +
-            'Pass --yes to acknowledge the expansion, or run with --dry-run first to review.');
-    }
-    const confirmed = await confirm({
-        message: `Proceed and broaden ${patchFilename} with ${added.length} newly discovered file(s)?`,
-        initialValue: false,
-    });
-    if (isCancel(confirmed) || !confirmed) {
-        cancel(`Skipped ${patchFilename}`);
-        return false;
-    }
-    return true;
-}
-function scanAdditionsNeedConfirmation(added) {
-    if (added.length === 0)
-        return false;
-    if (added.length > SCAN_ADD_COUNT_THRESHOLD)
-        return true;
-    return new Set(added.map((f) => dirname(f))).size >= SCAN_DIR_COUNT_THRESHOLD;
-}
-/**
- * Refuses scan adoptions whose candidate files import modules created by
- * later patches. Modeled on the `re-export --files` cross-patch
- * projection: the candidates' diffs are projected into the adopting
- * patch's queue entry, the queue lint runs baseline vs projection, and
- * only forward-import regressions attributable to the candidates block.
- * Staged-dependency declarations and inline lint-ignore markers are
- * honored automatically because the real lint rule evaluates them.
- * Covers broad `--scan`, `--scan-file`, and the `--scan-files` bulk flow
- * (all adopt through the same scan result), including dry-run.
- */
-export async function assertScanAdoptionsHaveNoForwardImports(args) {
-    const { patchesDir, engineDir, patchFilename, added, config } = args;
-    if (added.length === 0)
-        return;
-    const candidateDiff = await getDiffForFilesAgainstHead(engineDir, [...added]);
-    if (!candidateDiff.trim())
-        return;
-    const candidateNewFiles = buildNewFileTextProjection(candidateDiff);
-    const candidateCreations = detectNewFilesInDiff(candidateDiff);
-    const candidateAdditions = buildModifiedFileAdditionsFromDiff(candidateDiff);
-    const baseCtx = await buildPatchQueueContext(patchesDir, config);
-    const projectedEntries = baseCtx.entries.map((entry) => {
-        if (entry.filename !== patchFilename)
-            return entry;
-        return {
-            ...entry,
-            diff: `${entry.diff}\n${candidateDiff}`,
-            newFiles: new Map([...entry.newFiles, ...candidateNewFiles]),
-            createdFiles: new Set([...entry.createdFiles, ...candidateCreations]),
-            modifiedFileAdditions: new Map([...entry.modifiedFileAdditions, ...candidateAdditions]),
-        };
-    });
-    const baselineIssues = lintPatchQueue(baseCtx).filter((i) => i.severity === 'error');
-    const projectedIssues = lintPatchQueue({ ...baseCtx, entries: projectedEntries }).filter((i) => i.severity === 'error');
-    const addedSet = new Set(added);
-    const regressions = computeProjectedLintRegressions(baselineIssues, projectedIssues);
-    const offending = regressions.filter((issue) => issue.check === 'forward-import' && addedSet.has(issue.file));
-    // A forward registration (jar.mn packaging, a test manifest, ...) only
-    // regresses here because the candidates moved the registered file's
-    // creation to this patch, or because a candidate registers it: either way
-    // the adoption caused it, and the operator should declare it in the same
-    // pass as the import instead of meeting it later in the queue audit.
-    const registrations = regressions.filter((issue) => issue.check === 'forward-registration');
-    if (offending.length === 0 && registrations.length === 0)
-        return;
-    const details = offending.map((issue) => `  - ${issue.file}: ${issue.message}`).join('\n');
-    const registrationDetails = registrations
-        .map((issue) => `  - ${issue.file}: ${issue.message}`)
-        .join('\n');
-    const parts = [];
-    if (offending.length > 0) {
-        parts.push(`${offending.length} scanned file${offending.length === 1 ? '' : 's'} import modules created by later patches:\n${details}`);
-    }
-    if (registrations.length > 0) {
-        parts.push(`${registrations.length} forward registration${registrations.length === 1 ? '' : 's'} the adoption would leave dangling:\n${registrationDetails}`);
-    }
-    const report = await writeDeclarationsReport(dirname(resolve(patchesDir)), [...offending, ...registrations], args.declarationsOut);
-    throw new GeneralError(`Refusing to adopt scanned files into ${patchFilename}: ${parts.join('\n')}\n` +
-        (report !== undefined ? `${formatDeclarationsReport(report).join('\n')}\n` : '') +
-        formatForwardImportRemedy({
-            reRunHint: 're-running the scan',
-            issues: [...offending, ...registrations],
-            manifest: manifestFromQueue(baseCtx),
-            ...(args.config !== undefined ? { config: args.config } : {}),
-            ...categoryOf(baseCtx, patchFilename),
-        }));
-}
-/** The manifest rows a queue context carries, for remedy computations. */
-export function manifestFromQueue(ctx) {
-    return {
-        version: 1,
-        patches: ctx.entries.flatMap((entry) => (entry.metadata ? [entry.metadata] : [])),
-    };
-}
-/** `{ category }` of the named queue entry, or `{}` when it has no metadata. */
-export function categoryOf(ctx, filename) {
-    const category = ctx.entries.find((entry) => entry.filename === filename)?.metadata?.category;
-    return category !== undefined ? { category } : {};
-}
-/** Refuses explicit `--scan-file` additions that did not produce patch hunks. */
-export function assertScanFileAdditionsHaveDiffHunks(args) {
-    const { diffContent, patchFilename, previousFilesAffected, scanFiles } = args;
-    if (scanFiles === undefined)
-        return;
-    const previous = new Set(previousFilesAffected);
-    const diffFiles = new Set(extractAffectedFiles(diffContent));
-    const noDiffScanFiles = scanFiles.filter((file) => !previous.has(file) && !diffFiles.has(file));
-    if (noDiffScanFiles.length === 0)
-        return;
-    throw new InvalidArgumentError(`Refusing to re-export ${patchFilename} with --scan-file because ${noDiffScanFiles.length} explicit added path${noDiffScanFiles.length === 1 ? '' : 's'} produced no diff hunks (${noDiffScanFiles.join(', ')}). Remove unchanged paths or modify them before retrying.`, '--scan-file');
-}

package/dist/src/commands/re-export-single.d.ts

@@ -1,39 +0,0 @@
-/**
- * Single-patch refresh core for `fireforge re-export`, split out of
- * `re-export.ts` to stay under the per-file line budget. The orchestrator
- * loop calls {@link reExportSinglePatchWithIndexLockRetry} per selected
- * patch.
- */
-import type { PatchesManifest, PatchMetadata, ReExportOptions } from '../types/commands/index.js';
-import type { FireForgeConfig, ProjectPaths } from '../types/config.js';
-import type { AdjacentUnmanagedContext } from './re-export-adjacent.js';
-import type { ForeignDriftContext } from './re-export-drift.js';
-import { type ReExportLintContext } from './re-export-lint.js';
-export interface ReExportSinglePatchArgs {
-    /** Manifest row for the patch being refreshed. */
-    patch: PatchMetadata;
-    /** Resolved project paths. */
-    paths: ProjectPaths;
-    /** Patch queue manifest as loaded by the orchestrator. */
-    manifest: PatchesManifest;
-    /** Effective re-export options for this patch. */
-    options: ReExportOptions;
-    /** Whether the run is a dry run. */
-    isDryRun: boolean;
-    /** Project configuration. */
-    config: FireForgeConfig;
-    /** Adjacent-unmanaged-file reporting context. */
-    adjacentCtx: AdjacentUnmanagedContext;
-    /** Foreign-drift reporting context. */
-    driftCtx: ForeignDriftContext;
-    /** Per-patch lint context, including the shared lint cache. */
-    lintCtx: ReExportLintContext;
-}
-/**
- * Retries a single patch re-export exactly once when the failure is
- * transient git `index.lock` contention (an external git process holding
- * the engine repo's index). The retry re-enters `reExportSinglePatch`
- * from the top, so it re-reads clean state. A second lock failure
- * propagates to the loop's honest "N of M" accounting.
- */
-export declare function reExportSinglePatchWithIndexLockRetry(args: ReExportSinglePatchArgs): Promise<boolean>;