@hominis/fireforge 0.55.0 → 0.60.0

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

@@ -1,426 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Single-patch refresh core for `fireforge re-export`, split out of
- * `re-export.ts` to stay under the per-file line budget. A refresh is two
- * steps: a read-only prepare through the foreign-drift judgement, then the
- * commit. The orchestrator loop runs both per patch through
- * {@link reExportSinglePatchWithIndexLockRetry}; under
- * `--refuse-foreign-drift` it prepares every selected patch before
- * committing any.
- */
-import { join } from 'node:path';
-import { stdioIsInteractive } from '../core/destructive.js';
-import { enforceFreshFurnaceSources } from '../core/furnace-stale-export.js';
-import { getDiffForFilesAgainstHead } from '../core/git-diff.js';
-import { listTrackedInHead } from '../core/git-file-ops.js';
-import { updatePatchAndMetadata } from '../core/patch-export.js';
-import { withoutFields } from '../core/patch-export-update.js';
-import { buildLintIgnoreChecks, lintIgnoreRule, mergeLintIgnoreIds, } from '../core/patch-lint-ignore.js';
-import { buildProjectedManifest, enforcePatchPolicy } from '../core/patch-policy.js';
-import { isGitIndexLockConflict } from '../errors/git.js';
-import { readText } from '../utils/fs.js';
-import { info, success, warn } from '../utils/logger.js';
-import { sleep } from '../utils/sleep.js';
-import { findMissingFiles, reportAdjacentUnmanagedFiles } from './re-export-adjacent.js';
-import { reportForeignDrift } from './re-export-drift.js';
-import { buildHunkSelectedDiff, hunkSelectionOf } from './re-export-hunks.js';
-import { assertRefreshedBodyHasNoNewQueueErrors, lintReExportedPatch, refreshQueueCtxEntry, storeReExportLintResult, } from './re-export-lint.js';
-import { assertScanAdoptionsHaveNoForwardImports, assertScanFileAdditionsHaveDiffHunks, confirmBroadScanAdditions, scanPatchFilesForReExport, } from './re-export-scan.js';
-import { findPendingRegistrationCreates, planStaleRegistrationDrop, recordStaleRegistrationDrop, reportStaleRegistrationDrop, } from './re-export-stale-registrations.js';
-const GIT_INDEX_LOCK_RETRY_MS = 300;
-/**
- * Runs one re-export step, retrying it 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 the step from the top, so
- * it re-reads clean state. A second lock failure propagates to the loop's
- * honest "N of M" accounting.
- */
-async function withIndexLockRetry(patchFilename, step) {
-    try {
-        return await step();
-    }
-    catch (error) {
-        if (!isGitIndexLockConflict(error)) {
-            throw error;
-        }
-        warn(`${patchFilename}: git index.lock contention detected — retrying once after ${GIT_INDEX_LOCK_RETRY_MS} ms...`);
-        await sleep(GIT_INDEX_LOCK_RETRY_MS);
-        return await step();
-    }
-}
-/** Refreshes one patch, prepare and commit, under the index-lock retry. */
-export async function reExportSinglePatchWithIndexLockRetry(args) {
-    return withIndexLockRetry(args.patch.filename, async () => {
-        const prepared = await prepareSinglePatch(args);
-        return prepared !== undefined && (await commitPreparedPatch(args, prepared));
-    });
-}
-/**
- * Prepares one patch under the index-lock retry: everything up to and
- * including the foreign-drift judgement, with nothing written. Undefined
- * means the patch is skipped or refused.
- */
-export async function prepareSinglePatchWithIndexLockRetry(args) {
-    return withIndexLockRetry(args.patch.filename, () => prepareSinglePatch(args));
-}
-/** Commits one prepared patch under the index-lock retry. */
-export async function commitPreparedPatchWithIndexLockRetry(args, prepared) {
-    return withIndexLockRetry(args.patch.filename, () => commitPreparedPatch(args, prepared));
-}
-/**
- * The `--scan` branch: scans, gates the adoption on forward imports,
- * confirms a broad scan and, under `--refuse-adjacent-unmanaged`, judges
- * the neighbours the scan left. Undefined means the patch is not written.
- */
-async function adoptScannedFiles(args, currentFilesAffected) {
-    const { patch, paths, manifest, options, isDryRun, config, adjacentCtx } = args;
-    const scanResult = await scanPatchFilesForReExport({
-        currentFilesAffected,
-        engineDir: paths.engine,
-        manifest,
-        patchFilename: patch.filename,
-        isDryRun,
-        ...(options.scanFiles !== undefined ? { scanFiles: options.scanFiles } : {}),
-    });
-    // Forward-import gate at adoption time (runs in dry-run too): refuse
-    // to adopt unmanaged files that import modules created by later
-    // patches, because the after-the-fact lint failure this leaves behind
-    // is the field-reported footgun. Applies to broad --scan, --scan-file,
-    // and the --scan-files bulk assignments alike.
-    await assertScanAdoptionsHaveNoForwardImports({
-        patchesDir: paths.patches,
-        engineDir: paths.engine,
-        patchFilename: patch.filename,
-        added: scanResult.added,
-        config,
-        declarationsOut: options.declarationsOut,
-    });
-    if (options.scanFiles === undefined) {
-        const proceed = await confirmBroadScanAdditions({
-            patchFilename: patch.filename,
-            added: scanResult.added,
-            isDryRun,
-            yes: options.yes === true,
-            isInteractive: stdioIsInteractive(),
-        });
-        if (!proceed)
-            return undefined;
-    }
-    if (adjacentCtx.refuseAdjacentUnmanaged) {
-        const adjacentArgs = {
-            patch,
-            paths,
-            manifest,
-            currentFilesAffected: scanResult.updated,
-            ctx: adjacentCtx,
-            afterScan: true,
-        };
-        if (await reportAdjacentUnmanagedFiles(adjacentArgs))
-            return undefined;
-    }
-    return { updated: scanResult.updated, added: scanResult.added };
-}
-/**
- * The read-only half of a refresh: scan adoption, the adjacency belt, the
- * stale-furnace gate, the diff and the foreign-drift judgement. Nothing is
- * written. Undefined means the patch is skipped or refused.
- */
-async function prepareSinglePatch(args) {
-    const { patch, paths, manifest, options, adjacentCtx, driftCtx } = args;
-    const removed = new Set(options.expectRemoved ?? []);
-    const retainedFiles = patch.filesAffected.filter((file) => !removed.has(file));
-    let currentFilesAffected = retainedFiles;
-    let adoptedFiles = [];
-    for (const file of patch.filesAffected.filter((path) => removed.has(path)))
-        info(`  - ${file} (--expect-removed)`);
-    // --- Scan for new/removed files ---
-    if (options.scan) {
-        const adopted = await adoptScannedFiles(args, currentFilesAffected);
-        if (adopted === undefined)
-            return undefined;
-        currentFilesAffected = adopted.updated;
-        adoptedFiles = adopted.added;
-    }
-    else if (options.files === undefined) {
-        // When neither `--scan` nor `--files` is set and some of the manifest's
-        // claimed files no longer exist on disk, the re-export silently writes a
-        // refreshed body whose filesAffected still names the vanished paths.
-        // That is the documented contract, but it is also a footgun: a later
-        // `verify` then fails on manifest-consistency with no obvious trigger.
-        // Emit one advisory warning up-front when the drift is cheap to detect,
-        // so the operator can re-run with `--scan` or `--files` before the stale
-        // filesAffected lands in patches.json.
-        const args = { patch, paths, manifest, currentFilesAffected, ctx: adjacentCtx };
-        if (await reportAdjacentUnmanagedFiles(args))
-            return undefined;
-    }
-    // --- Explicit file-subset path ---
-    // When --files is given, the target filesAffected is authoritative: drop
-    // anything not in the list, add anything new. This is the surgical repair
-    // primitive that replaces hand-editing patches.json. The user has already
-    // acknowledged via confirmDestructive (done in the caller) that any drop
-    // is intentional.
-    if (options.files !== undefined) {
-        const requested = [...new Set(options.files)].sort();
-        currentFilesAffected = requested;
-        const removed = patch.filesAffected.filter((f) => !requested.includes(f));
-        const added = requested.filter((f) => !patch.filesAffected.includes(f));
-        for (const f of added)
-            info(`  + ${f}`);
-        for (const f of removed)
-            info(`  - ${f}`);
-    }
-    // Stale-furnace-source gate: re-export captures deployed engine copies, so
-    // a component source edited after the last furnace apply would land in the
-    // patch as its old deployed content. Refuse (or warn under
-    // --allow-stale-furnace) before diffing. Runs in dry-run too so the failure
-    // surfaces early.
-    await enforceFreshFurnaceSources(paths.root, currentFilesAffected, options.allowStaleFurnace === true, 're-export');
-    const absentFiles = await findMissingFiles(paths.engine, currentFilesAffected);
-    // A path absent from disk but tracked in engine HEAD is a deletion, and
-    // `git diff HEAD` renders it as a real `deleted file mode` section. Only
-    // a never-tracked path has nothing to diff. Skipping both alike meant a
-    // retired file quietly left the patch body while staying in its file
-    // list, so the patch then claimed a file it could not restore.
-    const trackedAbsent = await listTrackedInHead(paths.engine, absentFiles);
-    const deletedFiles = absentFiles.filter((f) => trackedAbsent.has(f));
-    const untrackedAbsent = absentFiles.filter((f) => !trackedAbsent.has(f));
-    if (untrackedAbsent.length === currentFilesAffected.length) {
-        warn(`Skipped ${patch.filename}: all affected files missing`);
-        warn(`Missing files: ${untrackedAbsent.join(', ')}`);
-        return undefined;
-    }
-    if (untrackedAbsent.length > 0) {
-        warn(`${patch.filename}: missing files will be skipped: ${untrackedAbsent.join(', ')}`);
-    }
-    if (deletedFiles.length > 0) {
-        info(`${patch.filename}: capturing deletion of ${deletedFiles.join(', ')}`);
-    }
-    const untrackedSet = new Set(untrackedAbsent);
-    const existingFiles = currentFilesAffected.filter((f) => !untrackedSet.has(f));
-    let diffContent = await getDiffForFilesAgainstHead(paths.engine, existingFiles);
-    const selection = hunkSelectionOf(options);
-    if (selection !== undefined) {
-        diffContent = await buildHunkSelectedDiff({
-            engineDir: paths.engine,
-            selection,
-            patchFilename: patch.filename,
-            oldBody: await readText(join(paths.patches, patch.filename)),
-            normalDiff: diffContent,
-            files: existingFiles,
-        });
-    }
-    assertScanFileAdditionsHaveDiffHunks({
-        diffContent,
-        patchFilename: patch.filename,
-        previousFilesAffected: patch.filesAffected,
-        scanFiles: options.scanFiles,
-    });
-    if (!diffContent.trim()) {
-        warn(`Skipped ${patch.filename}: no changes (files unchanged from HEAD)`);
-        return undefined;
-    }
-    // Foreign-drift preview + optional hard stop: show which
-    // payload lines are about to enter the body that the old body did not
-    // carry, the case where a concurrent session's uncommitted edits in
-    // owned files would be silently absorbed. Always previews (including
-    // dry-run and --scan). Refuses only under --refuse-foreign-drift. Covers
-    // the files the patch already owned; adopted and retired files are the
-    // run's stated intent, not drift.
-    if (await reportForeignDrift({
-        patch,
-        patchesDir: paths.patches,
-        engineDir: paths.engine,
-        newDiffContent: diffContent,
-        ctx: driftCtx,
-        ownedFiles: retainedFiles,
-        adoptedFiles,
-    })) {
-        return undefined;
-    }
-    return { currentFilesAffected, existingFiles, diffContent };
-}
-/**
- * The writing half of a refresh: metadata, the manifest policy, the queue
- * projection, the per-patch lint and the write (or, in a dry run, its
- * report). Returns true once the patch is written or would be.
- */
-async function commitPreparedPatch(args, prepared) {
-    const { patch, paths, manifest, options, isDryRun, config, adjacentCtx, lintCtx } = args;
-    const { currentFilesAffected, existingFiles, diffContent } = prepared;
-    const { updates, ignoreChecks, effectiveTier, existingIgnoreSet, flagIgnoreSet } = computeReExportUpdates(patch, options, currentFilesAffected);
-    const stalePlan = planStaleRegistrationDrop(manifest, patch, currentFilesAffected, await findPendingRegistrationCreates(paths.engine, manifest, patch, currentFilesAffected, adjacentCtx.expectedNew));
-    if (stalePlan !== undefined)
-        reportStaleRegistrationDrop(patch.filename, stalePlan, isDryRun);
-    const unset = applyStaleRegistrationDrop(stalePlan, updates);
-    enforceProjectedManifestPolicy({ config, manifest, patch, updates, options });
-    // Cross-patch projection gate (runs in dry-run too): the refreshed body
-    // must not introduce queue-level errors the current queue lacks, e.g. an
-    // earlier owner gaining an import of a later patch's module. Cheap
-    // (in-memory) and more actionable than the per-patch lint, so it fires
-    // first.
-    assertRefreshedBodyHasNoNewQueueErrors({
-        lintCtx,
-        patchFilename: patch.filename,
-        diffContent,
-        forceUnsafe: options.forceUnsafe === true,
-    });
-    // Lint against the once-per-invocation hoisted context (queue context +
-    // queue-wide checkJs program + per-patch result cache) instead of
-    // rebuilding ~37 s of setup for every patch in the loop.
-    const projectedMetadata = withoutFields({ ...patch, ...updates }, unset);
-    const lintResult = await lintReExportedPatch({
-        lintCtx,
-        patch,
-        projectedMetadata,
-        existingFiles,
-        diffContent,
-        ...(options.skipLint !== undefined ? { skipLint: options.skipLint } : {}),
-        ...(ignoreChecks !== undefined ? { ignoreChecks } : {}),
-        ...(effectiveTier !== undefined ? { patchTier: effectiveTier } : {}),
-    });
-    if (isDryRun) {
-        info(`[dry-run] ${patch.filename}: ${existingFiles.length} file(s)`);
-        if (effectiveTier !== undefined && effectiveTier !== patch.tier) {
-            info(`[dry-run] ${patch.filename}: tier would become ${effectiveTier}`);
-        }
-        const addedIgnores = [...flagIgnoreSet].filter((id) => !existingIgnoreSet.has(id));
-        if (addedIgnores.length > 0) {
-            info(`[dry-run] ${patch.filename}: lintIgnore would gain ${addedIgnores.join(', ')}`);
-        }
-        // Memory-only: later `--all --dry-run` iterations project against this
-        // patch's would-be body, exactly as the real run does after its write.
-        refreshQueueCtxEntry(lintCtx, patch.filename, diffContent);
-    }
-    else {
-        await commitRefreshedPatch({
-            patch,
-            paths,
-            manifest,
-            options,
-            config,
-            lintCtx,
-            diffContent,
-            updates,
-            unset,
-            stalePlan,
-            projectedMetadata,
-            existingFiles,
-            lintResult,
-        });
-    }
-    return true;
-}
-/** Manifest-level policy gate over the projected row (ranges, gaps, collisions). */
-function enforceProjectedManifestPolicy(args) {
-    const { config, manifest, patch, updates, options } = args;
-    enforcePatchPolicy({
-        config,
-        manifest: buildProjectedManifest(manifest, manifest.patches.map((entry) => entry.filename === patch.filename ? { ...entry, ...updates } : entry)),
-        command: 're-export',
-        forceUnsafe: options.forceUnsafe === true,
-        // A re-export changes only this row's contents, so only its findings
-        // can be new; another patch's stale row must not fail this one.
-        scope: [patch.filename],
-        hints: {
-            'reserved-files': 'A path whose engine copy is back at HEAD can be dropped from the patch with ' +
-                '--expect-removed <path>; any other path needs its reserved allowlist entry.',
-        },
-    });
-}
-/**
- * Writes the refreshed body + manifest row atomically under the patch
- * directory lock (a split write would let a concurrent queue mutation
- * leave body and `filesAffected` disagreeing), then keeps the run's
- * in-memory state honest: the queue context entry is refreshed and the
- * fresh lint result is stored keyed against the just-written body (the
- * state a repeat invocation will observe), and the in-memory
- * manifest row mirrors the on-disk write for later loop iterations
- * (notably `--all --scan`, where `getClaimedFiles` reads this manifest).
- */
-async function commitRefreshedPatch(args) {
-    const { patch, paths, manifest, options, config, lintCtx, diffContent, updates } = args;
-    const bodyChanged = await updatePatchAndMetadata({
-        patchesDir: paths.patches,
-        filename: patch.filename,
-        newContent: diffContent,
-        updates,
-        ...(args.unset.length > 0 ? { unset: args.unset } : {}),
-        onCommitted: staleRecorder(paths.patches, patch.filename, args.stalePlan),
-        policyGate: {
-            config,
-            command: 're-export',
-            forceUnsafe: options.forceUnsafe === true,
-            scope: [patch.filename],
-        },
-    });
-    refreshQueueCtxEntry(lintCtx, patch.filename, diffContent);
-    if (args.lintResult !== null) {
-        await storeReExportLintResult(lintCtx, patch.filename, args.projectedMetadata, args.existingFiles, args.lintResult);
-    }
-    const patchIndex = manifest.patches.findIndex((pm) => pm.filename === patch.filename);
-    if (patchIndex !== -1) {
-        const existingEntry = manifest.patches[patchIndex];
-        if (existingEntry) {
-            manifest.patches[patchIndex] = withoutFields({ ...existingEntry, ...updates }, args.unset);
-        }
-    }
-    // A bulk run refreshes every patch. Saying "Re-exported" for one whose body
-    // did not move buries the patches that did move. The run still counts this
-    // patch as successfully refreshed, so `--stamp` completeness is unaffected.
-    if (bodyChanged) {
-        success(`Re-exported ${patch.filename}`);
-    }
-    else {
-        info(`Unchanged ${patch.filename}`);
-    }
-}
-/** The history hook for a write that drops stale registrations, if any. */
-function staleRecorder(patchesDir, patchFilename, plan) {
-    if (plan === undefined)
-        return undefined;
-    return () => recordStaleRegistrationDrop(patchesDir, patchFilename, plan);
-}
-/**
- * Folds the stale-registration drop into `updates`: the kept staged block
- * is set, or the field is returned for unsetting when nothing is left.
- */
-function applyStaleRegistrationDrop(plan, updates) {
-    if (plan === undefined)
-        return [];
-    if (plan.stagedDependencies === undefined)
-        return ['stagedDependencies'];
-    updates.stagedDependencies = plan.stagedDependencies;
-    return [];
-}
-/**
- * Threads the patch's own `lintIgnore` list through so the per-patch
- * suppression honoured by export/export-all is also honoured here. A
- * re-export could otherwise not refresh an advisory-noisy but intentional
- * patch without the blunt `--skip-lint`. The paired `patch.tier` threads the
- * explicit branding-threshold opt-in the same way. The CLI flags `--tier`
- * and `--lint-ignore` participate with append/union semantics (explicit
- * removal lives on `fireforge patch lint-ignore`), computed before the lint
- * pass so the new intent takes effect on this invocation.
- */
-function computeReExportUpdates(patch, options, currentFilesAffected) {
-    const existingIgnoreSet = new Set((patch.lintIgnore ?? []).map(lintIgnoreRule));
-    const flagIgnoreSet = new Set(options.lintIgnore ?? []);
-    const effectiveLintIgnore = mergeLintIgnoreIds(patch.lintIgnore, [...flagIgnoreSet]);
-    const updates = {
-        filesAffected: currentFilesAffected,
-    };
-    if (options.tier !== undefined) {
-        updates.tier = options.tier;
-    }
-    if (effectiveLintIgnore !== undefined && flagIgnoreSet.size > 0) {
-        updates.lintIgnore = effectiveLintIgnore;
-    }
-    return {
-        updates,
-        ignoreChecks: buildLintIgnoreChecks(effectiveLintIgnore),
-        effectiveTier: options.tier ?? patch.tier,
-        existingIgnoreSet,
-        flagIgnoreSet,
-    };
-}

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

@@ -1,39 +0,0 @@
-import type { PatchesManifest, PatchMetadata, PatchStagedDependencies, PatchStagedForwardImport, PatchStagedRegistration } from '../types/commands/index.js';
-/** The holder's registrations split by whether the queue still owns `creates`. */
-export interface StaleRegistrationPlan {
-    /** Registrations whose `creates` path no patch owns. */
-    dropped: PatchStagedRegistration[];
-    /** Unowned registrations kept because their `creates` file is pending adoption. */
-    pending: PatchStagedRegistration[];
-    /** The staged block to write, or undefined when nothing is left. */
-    stagedDependencies: PatchStagedDependencies | undefined;
-}
-/**
- * The unowned `creates` paths of `patch`'s registrations that are pending
- * adoption: the file exists in `engine/`, or is an `--expect-new` path of
- * this run. Such a registration is waiting for its subject patch's scan.
- */
-export declare function findPendingRegistrationCreates(engineDir: string, manifest: PatchesManifest, patch: PatchMetadata, currentFilesAffected: readonly string[], expectedNew: ReadonlySet<string>): Promise<Set<string>>;
-/**
- * Finds `patch`'s registrations whose `creates` path no patch in the queue
- * owns, judging `patch` by the file list this re-export will write. A
- * registration whose `creates` path is in `pending` (see
- * {@link findPendingRegistrationCreates}) is kept and reported instead.
- * Returns undefined when nothing is stale or pending.
- */
-export declare function planStaleRegistrationDrop(manifest: PatchesManifest, patch: PatchMetadata, currentFilesAffected: readonly string[], pendingCreates?: ReadonlySet<string>): StaleRegistrationPlan | undefined;
-/** Names each dropped and each kept-pending registration, in both a dry run and a write. */
-export declare function reportStaleRegistrationDrop(patchFilename: string, plan: StaleRegistrationPlan, isDryRun: boolean): void;
-/** One declaration a re-export pruned, as the history log records it. */
-export type PrunedStagedDeclaration = ({
-    kind: 'registration';
-} & PatchStagedRegistration) | ({
-    kind: 'import';
-} & PatchStagedForwardImport);
-/**
- * Records declarations a re-export pruned from one patch as a delta, like
- * `staged-dependency --remove`.
- */
-export declare function recordStagedDeclarationPrune(patchesDir: string, patchFilename: string, removed: readonly PrunedStagedDeclaration[], what: string): Promise<void>;
-/** Records the dropped registrations as a delta, like `staged-dependency --remove`. */
-export declare function recordStaleRegistrationDrop(patchesDir: string, patchFilename: string, plan: StaleRegistrationPlan): Promise<void>;

package/dist/src/commands/re-export-stale-registrations.js

@@ -1,106 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Re-export prunes a staged registration the queue can no longer satisfy.
- *
- * A merge that deletes a file whose jar.mn line lives in another patch
- * leaves the staged registration on that patch: lint warns
- * `staged-dependency-unused`, and the stale declaration keeps the holder
- * measuring above a just-lowered size ceiling. When no patch in
- * the queue owns a registration's `creates` path any more, the declaration
- * cannot be met, so the holder's own re-export drops it and says so.
- *
- * A registration whose `creates` file exists in `engine/`, or is an
- * `--expect-new` path of the run, is kept: a manifest owner's re-export can
- * run between declaring the registration and the scan that adopts the
- * file, and pruning it there would break the scan that needs it next.
- */
-import { join } from 'node:path';
-import { appendHistoryBestEffort } from '../core/history-log.js';
-import { pathExists } from '../utils/fs.js';
-import { info } from '../utils/logger.js';
-/**
- * The unowned `creates` paths of `patch`'s registrations that are pending
- * adoption: the file exists in `engine/`, or is an `--expect-new` path of
- * this run. Such a registration is waiting for its subject patch's scan.
- */
-export async function findPendingRegistrationCreates(engineDir, manifest, patch, currentFilesAffected, expectedNew) {
-    const owned = ownedPaths(manifest, patch, currentFilesAffected);
-    const pending = new Set();
-    for (const registration of patch.stagedDependencies?.registrations ?? []) {
-        const creates = registration.creates;
-        if (owned.has(creates) || pending.has(creates))
-            continue;
-        if (expectedNew.has(creates) || (await pathExists(join(engineDir, creates)))) {
-            pending.add(creates);
-        }
-    }
-    return pending;
-}
-function ownedPaths(manifest, patch, currentFilesAffected) {
-    const owned = new Set(currentFilesAffected);
-    for (const entry of manifest.patches) {
-        if (entry.filename === patch.filename)
-            continue;
-        for (const file of entry.filesAffected)
-            owned.add(file);
-    }
-    return owned;
-}
-/**
- * Finds `patch`'s registrations whose `creates` path no patch in the queue
- * owns, judging `patch` by the file list this re-export will write. A
- * registration whose `creates` path is in `pending` (see
- * {@link findPendingRegistrationCreates}) is kept and reported instead.
- * Returns undefined when nothing is stale or pending.
- */
-export function planStaleRegistrationDrop(manifest, patch, currentFilesAffected, pendingCreates = new Set()) {
-    const registrations = patch.stagedDependencies?.registrations ?? [];
-    if (registrations.length === 0)
-        return undefined;
-    const owned = ownedPaths(manifest, patch, currentFilesAffected);
-    const unowned = registrations.filter((registration) => !owned.has(registration.creates));
-    const pending = unowned.filter((registration) => pendingCreates.has(registration.creates));
-    const dropped = unowned.filter((registration) => !pendingCreates.has(registration.creates));
-    if (dropped.length === 0 && pending.length === 0)
-        return undefined;
-    const kept = registrations.filter((registration) => !dropped.includes(registration));
-    const forwardImports = patch.stagedDependencies?.forwardImports ?? [];
-    const staged = {
-        ...(forwardImports.length > 0 ? { forwardImports } : {}),
-        ...(kept.length > 0 ? { registrations: kept } : {}),
-    };
-    return {
-        dropped,
-        pending,
-        stagedDependencies: Object.keys(staged).length > 0 ? staged : undefined,
-    };
-}
-/** Names each dropped and each kept-pending registration, in both a dry run and a write. */
-export function reportStaleRegistrationDrop(patchFilename, plan, isDryRun) {
-    const verb = isDryRun ? 'would drop' : 'drops';
-    for (const registration of plan.dropped) {
-        info(`${patchFilename}: ${verb} staged registration ${registration.file} "${registration.line.trim()}": ` +
-            `no patch in the queue creates ${registration.creates} any more.`);
-    }
-    for (const registration of plan.pending) {
-        info(`${patchFilename}: staged registration ${registration.file} "${registration.line.trim()}" ` +
-            `for ${registration.creates} kept: file exists but no patch owns it yet.`);
-    }
-}
-/**
- * Records declarations a re-export pruned from one patch as a delta, like
- * `staged-dependency --remove`.
- */
-export async function recordStagedDeclarationPrune(patchesDir, patchFilename, removed, what) {
-    if (removed.length === 0)
-        return;
-    await appendHistoryBestEffort(patchesDir, {
-        operation: 're-export-staged-prune',
-        args: { filename: patchFilename, removed: [...removed] },
-        result: 'ok',
-    }, `re-export pruned ${what} on ${patchFilename}`);
-}
-/** Records the dropped registrations as a delta, like `staged-dependency --remove`. */
-export async function recordStaleRegistrationDrop(patchesDir, patchFilename, plan) {
-    await recordStagedDeclarationPrune(patchesDir, patchFilename, plan.dropped.map((registration) => ({ kind: 'registration', ...registration })), 'stale staged registrations');
-}

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

@@ -1,44 +0,0 @@
-/**
- * The one-line end-of-run summary of a multi-patch `re-export`.
- *
- * A long run interleaves per-patch lint output, drift previews and
- * refusals, and the patches it wrote were easy to confuse with the one it
- * did not. The summary names both sets and why each unwritten patch was
- * not written, so the re-run list is one line to read.
- */
-/** What became of each selected patch. */
-export interface ReExportRunTally {
-    /** Selected patches, in run order. */
-    selected: readonly string[];
-    /** Patches written (or, in a dry run, that would be written). */
-    written: readonly string[];
-    /** Patches whose re-export threw. */
-    failed: readonly string[];
-    /** Patches refused by `--refuse-adjacent-unmanaged`. */
-    refusedAdjacent: readonly string[];
-    /** Patches refused by `--refuse-foreign-drift`. */
-    refusedDrift: readonly string[];
-    /**
-     * Patches prepared cleanly but not written because a
-     * `--refuse-foreign-drift` refusal elsewhere in the run wrote none.
-     */
-    heldBack?: readonly string[];
-    /** Whether the run is a dry run. */
-    isDryRun: boolean;
-}
-/**
- * Renders the summary, or undefined for a single-patch run, where the
- * outcome line already says everything.
- */
-export declare function formatReExportRunSummary(tally: ReExportRunTally): string | undefined;
-/**
- * The note printed after a run that wrote a patch whose files per-patch
- * checkJs type-checks. That pass is not the project pass: its programs see
- * only patch-owned modules and heads, so `fireforge typecheck` can still
- * report errors in the same files. Undefined when no such patch was
- * written.
- *
- * @param checkJsWritten - Written patches with per-patch checkJs files
- * @param isDryRun - Whether the run is a dry run
- */
-export declare function formatCheckJsProjectPassNote(checkJsWritten: readonly string[], isDryRun: boolean): string | undefined;

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

@@ -1,59 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The one-line end-of-run summary of a multi-patch `re-export`.
- *
- * A long run interleaves per-patch lint output, drift previews and
- * refusals, and the patches it wrote were easy to confuse with the one it
- * did not. The summary names both sets and why each unwritten patch was
- * not written, so the re-run list is one line to read.
- */
-/**
- * Renders the summary, or undefined for a single-patch run, where the
- * outcome line already says everything.
- */
-export function formatReExportRunSummary(tally) {
-    if (tally.selected.length <= 1)
-        return undefined;
-    const written = new Set(tally.written);
-    const reasons = new Map();
-    for (const name of tally.failed)
-        reasons.set(name, 'failed');
-    for (const name of tally.refusedAdjacent)
-        reasons.set(name, 'refused: adjacent unmanaged');
-    for (const name of tally.refusedDrift)
-        reasons.set(name, 'refused: foreign drift');
-    for (const name of tally.heldBack ?? [])
-        reasons.set(name, 'held back: another patch refused');
-    const notWritten = tally.selected
-        .filter((name) => !written.has(name))
-        .map((name) => `${name} (${reasons.get(name) ?? 'skipped'})`);
-    const verb = tally.isDryRun ? 'would write' : 'wrote';
-    const writtenPart = tally.written.length > 0
-        ? `${verb} ${tally.written.length} of ${tally.selected.length}: ${tally.written.join(', ')}`
-        : `${verb} 0 of ${tally.selected.length}`;
-    const notWrittenPart = notWritten.length > 0
-        ? `; ${tally.isDryRun ? 'would NOT write' : 'NOT written'}: ${notWritten.join(', ')}`
-        : '';
-    const heldBackPart = (tally.heldBack ?? []).length > 0
-        ? ` Nothing ${tally.isDryRun ? 'would be' : 'was'} written because --refuse-foreign-drift ` +
-            `refused ${tally.refusedDrift.join(', ')}.`
-        : '';
-    return `Re-export summary: ${writtenPart}${notWrittenPart}.${heldBackPart}`;
-}
-/**
- * The note printed after a run that wrote a patch whose files per-patch
- * checkJs type-checks. That pass is not the project pass: its programs see
- * only patch-owned modules and heads, so `fireforge typecheck` can still
- * report errors in the same files. Undefined when no such patch was
- * written.
- *
- * @param checkJsWritten - Written patches with per-patch checkJs files
- * @param isDryRun - Whether the run is a dry run
- */
-export function formatCheckJsProjectPassNote(checkJsWritten, isDryRun) {
-    if (checkJsWritten.length === 0)
-        return undefined;
-    return (`Per-patch checkJs only (${checkJsWritten.join(', ')}): it is not the project pass, which ` +
-        `can still report errors in these files. Run "fireforge typecheck" for the project pass` +
-        `${isDryRun ? ' once the patches are written' : ' before committing'}.`);
-}