@hominis/fireforge 0.49.2 → 0.51.0

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

@@ -5,19 +5,25 @@
  * loop calls {@link reExportSinglePatchWithIndexLockRetry} per selected
  * patch.
  */
+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 { planStaleRegistrationDrop, recordStaleRegistrationDrop, reportStaleRegistrationDrop, } from './re-export-stale-registrations.js';
 const GIT_INDEX_LOCK_RETRY_MS = 300;
 /**
  * Retries a single patch re-export exactly once when the failure is
@@ -39,47 +45,74 @@ export async function reExportSinglePatchWithIndexLockRetry(args) {
         return await reExportSinglePatch(args);
     }
 }
+/**
+ * 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 };
+}
 async function reExportSinglePatch(args) {
     const { patch, paths, manifest, options, isDryRun, config, adjacentCtx, driftCtx, lintCtx } = args;
     const removed = new Set(options.expectRemoved ?? []);
-    let currentFilesAffected = patch.filesAffected.filter((file) => !removed.has(file));
+    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 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,
-        });
-        if (options.scanFiles === undefined) {
-            const isInteractive = stdioIsInteractive();
-            const proceed = await confirmBroadScanAdditions({
-                patchFilename: patch.filename,
-                added: scanResult.added,
-                isDryRun,
-                yes: options.yes === true,
-                isInteractive,
-            });
-            if (!proceed) {
-                return false;
-            }
-        }
-        currentFilesAffected = scanResult.updated;
+        const adopted = await adoptScannedFiles(args, currentFilesAffected);
+        if (adopted === undefined)
+            return false;
+        currentFilesAffected = adopted.updated;
+        adoptedFiles = adopted.added;
     }
     else if (options.files === undefined) {
         // When neither `--scan` nor `--files` is set and some of the manifest's
@@ -138,7 +171,17 @@ async function reExportSinglePatch(args) {
     }
     const untrackedSet = new Set(untrackedAbsent);
     const existingFiles = currentFilesAffected.filter((f) => !untrackedSet.has(f));
-    const diffContent = await getDiffForFilesAgainstHead(paths.engine, existingFiles);
+    let diffContent = await getDiffForFilesAgainstHead(paths.engine, existingFiles);
+    const selection = hunkSelectionOf(options);
+    if (selection !== undefined) {
+        diffContent = await buildHunkSelectedDiff({
+            engineDir: paths.engine,
+            selection,
+            oldBody: await readText(join(paths.patches, patch.filename)),
+            normalDiff: diffContent,
+            files: existingFiles,
+        });
+    }
     assertScanFileAdditionsHaveDiffHunks({
         diffContent,
         patchFilename: patch.filename,
@@ -153,17 +196,25 @@ async function reExportSinglePatch(args) {
     // 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.
+    // 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 false;
     }
     const { updates, ignoreChecks, effectiveTier, existingIgnoreSet, flagIgnoreSet } = computeReExportUpdates(patch, options, currentFilesAffected);
+    const stalePlan = planStaleRegistrationDrop(manifest, patch, currentFilesAffected);
+    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
@@ -179,7 +230,7 @@ async function reExportSinglePatch(args) {
     // 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 = { ...patch, ...updates };
+    const projectedMetadata = withoutFields({ ...patch, ...updates }, unset);
     const lintResult = await lintReExportedPatch({
         lintCtx,
         patch,
@@ -213,6 +264,8 @@ async function reExportSinglePatch(args) {
             lintCtx,
             diffContent,
             updates,
+            unset,
+            stalePlan,
             projectedMetadata,
             existingFiles,
             lintResult,
@@ -228,6 +281,13 @@ function enforceProjectedManifestPolicy(args) {
         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.',
+        },
     });
 }
 /**
@@ -247,11 +307,13 @@ async function commitRefreshedPatch(args) {
         filename: patch.filename,
         newContent: diffContent,
         updates,
-        onCommitted: undefined,
+        ...(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);
@@ -262,10 +324,7 @@ async function commitRefreshedPatch(args) {
     if (patchIndex !== -1) {
         const existingEntry = manifest.patches[patchIndex];
         if (existingEntry) {
-            manifest.patches[patchIndex] = {
-                ...existingEntry,
-                ...updates,
-            };
+            manifest.patches[patchIndex] = withoutFields({ ...existingEntry, ...updates }, args.unset);
         }
     }
     // A bulk run refreshes every patch. Saying "Re-exported" for one whose body
@@ -278,6 +337,24 @@ async function commitRefreshedPatch(args) {
         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
@@ -289,10 +366,9 @@ async function commitRefreshedPatch(args) {
  * pass so the new intent takes effect on this invocation.
  */
 function computeReExportUpdates(patch, options, currentFilesAffected) {
-    const existingIgnoreSet = new Set(patch.lintIgnore ?? []);
+    const existingIgnoreSet = new Set((patch.lintIgnore ?? []).map(lintIgnoreRule));
     const flagIgnoreSet = new Set(options.lintIgnore ?? []);
-    const mergedIgnoreSet = new Set([...existingIgnoreSet, ...flagIgnoreSet]);
-    const effectiveLintIgnore = mergedIgnoreSet.size > 0 ? [...mergedIgnoreSet] : undefined;
+    const effectiveLintIgnore = mergeLintIgnoreIds(patch.lintIgnore, [...flagIgnoreSet]);
     const updates = {
         filesAffected: currentFilesAffected,
     };
@@ -304,7 +380,7 @@ function computeReExportUpdates(patch, options, currentFilesAffected) {
     }
     return {
         updates,
-        ignoreChecks: effectiveLintIgnore ? new Set(effectiveLintIgnore) : undefined,
+        ignoreChecks: buildLintIgnoreChecks(effectiveLintIgnore),
         effectiveTier: options.tier ?? patch.tier,
         existingIgnoreSet,
         flagIgnoreSet,

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

@@ -0,0 +1,18 @@
+import type { PatchesManifest, PatchMetadata, PatchStagedDependencies, 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[];
+    /** The staged block to write, or undefined when nothing is left. */
+    stagedDependencies: PatchStagedDependencies | undefined;
+}
+/**
+ * Finds `patch`'s registrations whose `creates` path no patch in the queue
+ * owns, judging `patch` by the file list this re-export will write.
+ * Returns undefined when nothing is stale.
+ */
+export declare function planStaleRegistrationDrop(manifest: PatchesManifest, patch: PatchMetadata, currentFilesAffected: readonly string[]): StaleRegistrationPlan | undefined;
+/** Names each dropped registration, in both a dry run and a write. */
+export declare function reportStaleRegistrationDrop(patchFilename: string, plan: StaleRegistrationPlan, isDryRun: boolean): void;
+/** Records the dropped declarations 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

@@ -0,0 +1,62 @@
+// 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
+ * left the staged registration on that patch: re-export kept it, lint then
+ * warned `staged-dependency-unused`, and the stale declaration also kept
+ * 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.
+ */
+import { appendHistoryBestEffort } from '../core/history-log.js';
+import { info } from '../utils/logger.js';
+/**
+ * Finds `patch`'s registrations whose `creates` path no patch in the queue
+ * owns, judging `patch` by the file list this re-export will write.
+ * Returns undefined when nothing is stale.
+ */
+export function planStaleRegistrationDrop(manifest, patch, currentFilesAffected) {
+    const registrations = patch.stagedDependencies?.registrations ?? [];
+    if (registrations.length === 0)
+        return undefined;
+    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);
+    }
+    const dropped = registrations.filter((registration) => !owned.has(registration.creates));
+    if (dropped.length === 0)
+        return undefined;
+    const kept = registrations.filter((registration) => owned.has(registration.creates));
+    const forwardImports = patch.stagedDependencies?.forwardImports ?? [];
+    const staged = {
+        ...(forwardImports.length > 0 ? { forwardImports } : {}),
+        ...(kept.length > 0 ? { registrations: kept } : {}),
+    };
+    return {
+        dropped,
+        stagedDependencies: Object.keys(staged).length > 0 ? staged : undefined,
+    };
+}
+/** Names each dropped 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.`);
+    }
+}
+/** Records the dropped declarations as a delta, like `staged-dependency --remove`. */
+export async function recordStaleRegistrationDrop(patchesDir, patchFilename, plan) {
+    await appendHistoryBestEffort(patchesDir, {
+        operation: 're-export-staged-prune',
+        args: {
+            filename: patchFilename,
+            removed: plan.dropped.map((registration) => ({ kind: 'registration', ...registration })),
+        },
+        result: 'ok',
+    }, `re-export pruned stale staged registrations on ${patchFilename}`);
+}

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

@@ -0,0 +1,28 @@
+/**
+ * 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[];
+    /** 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;

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

@@ -0,0 +1,36 @@
+// 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');
+    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(', ')}`
+        : '';
+    return `Re-export summary: ${writtenPart}${notWrittenPart}.`;
+}