@hominis/fireforge 0.45.0 → 0.46.1

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

@@ -1,28 +1,27 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join } from 'node:path';
-import { getProjectPaths } from '../core/config.js';
 import { appendHistory, confirmDestructive, } 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 { extractAffectedFiles } from '../core/patch-apply.js';
 import { updatePatchAndMetadata } from '../core/patch-export.js';
-import { buildModifiedFileAdditionsFromDiff, buildPatchQueueContext, formatPatchLintIssue, lintPatchQueue, } from '../core/patch-lint.js';
+import { buildPatchQueueContext, formatPatchLintIssue, lintPatchQueue, } from '../core/patch-lint.js';
 import { computeProjectedLintRegressions } from '../core/patch-lint-projection.js';
 import { loadPatchesManifest } from '../core/patch-manifest.js';
 import { buildProjectedManifest, enforcePatchPolicy } from '../core/patch-policy.js';
-import { buildNewFileTextProjection } from '../core/patch-transform.js';
 import { InvalidArgumentError } from '../errors/base.js';
 import { pathExists } from '../utils/fs.js';
 import { info, outro, success, warn } from '../utils/logger.js';
 import { runPatchLint } from './export-shared.js';
+import { projectEntryBody } from './patch/entry-projection.js';
 /**
  * Computes the effective `tier` and `lintIgnore` carrying both the patch's
  * existing values and the CLI flag overrides.
  *
- * Tier resolution: the CLI flag takes precedence; the patch's existing tier
+ * Tier resolution: the CLI flag takes precedence. The patch's existing tier
  * is the fallback. Lint-ignore resolution: union of the patch's existing list
- * and the CLI flag values, de-duplicated; an empty result returns `undefined`
+ * and the CLI flag values, de-duplicated. An empty result returns `undefined`
  * so the caller can drop the field rather than write an empty array.
  */
 function resolveEffectiveTierAndLintIgnore(target, options) {
@@ -42,17 +41,11 @@ function resolveEffectiveTierAndLintIgnore(target, options) {
  */
 async function runProjectedCrossPatchLint(patchesDir, targetFilename, projectedDiff) {
     const baseCtx = await buildPatchQueueContext(patchesDir);
-    const projectedNewFiles = buildNewFileTextProjection(projectedDiff);
-    const projectedModifiedFileAdditions = buildModifiedFileAdditionsFromDiff(projectedDiff);
+    const projection = projectEntryBody(projectedDiff);
     const projectedEntries = baseCtx.entries.map((entry) => {
         if (entry.filename !== targetFilename)
             return entry;
-        return {
-            ...entry,
-            diff: projectedDiff,
-            newFiles: projectedNewFiles,
-            modifiedFileAdditions: projectedModifiedFileAdditions,
-        };
+        return { ...entry, ...projection };
     });
     const baselineIssues = lintPatchQueue(baseCtx).filter((i) => i.severity === 'error');
     const projectedIssues = lintPatchQueue({ entries: projectedEntries }).filter((i) => i.severity === 'error');
@@ -117,7 +110,7 @@ async function confirmFilesModeProjection(args) {
         title: `Re-export ${target.filename} with --files`,
         summary,
         // A captured deletion still needs the confirmation: the patch will now
-        // REMOVE those files wherever it is applied, which is the same class of
+        // remove those files wherever it is applied, which is the same class of
         // consequence as shrinking the scope.
         yes: removed.length === 0 && deletedFiles.length === 0 ? true : options.yes === true,
         dryRun: isDryRun,
@@ -129,13 +122,13 @@ async function confirmFilesModeProjection(args) {
  * Splits the requested paths into what can be diffed and what is a deletion.
  *
  * A path absent from disk is one of two very different things, and
- * collapsing them is what made a DELETION impossible to capture.
+ * collapsing them is what made a deletion impossible to capture.
  *
  * Tracked in HEAD: a deletion. `git diff HEAD -- <path>` renders it as a
- * proper `deleted file mode` section, so it STAYS in the diff scope. (The
- * comment this replaces claimed the diff "would fail" on any missing path —
- * true only for the never-tracked case.) Dropping these produced the
- * dangerous shape: a re-export that reported success while writing a patch
+ * proper `deleted file mode` section, so it stays in the diff scope. (The
+ * comment this replaces claimed the diff "would fail" on any missing path,
+ * which is true only for the never-tracked case.) Dropping these produced
+ * the dangerous shape: a re-export that reported success while writing a patch
  * whose own file list claimed a path it did not restore, so a fresh clone
  * would apply it and resurrect exactly what the change meant to remove.
  *
@@ -192,8 +185,8 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
         throw new InvalidArgumentError('reExportFilesInPlace called with no --files.', '--files');
     }
     const requested = [...new Set(filesOption)].sort();
-    // Stale-furnace-source gate: same refusal as the generic re-export path —
-    // the projected diff would capture stale deployed copies.
+    // Stale-furnace-source gate: same refusal as the generic re-export path,
+    // since the projected diff would capture stale deployed copies.
     await enforceFreshFurnaceSources(paths.root, requested, options.allowStaleFurnace === true, 're-export');
     const removed = target.filesAffected.filter((f) => !requested.includes(f));
     const added = requested.filter((f) => !target.filesAffected.includes(f));
@@ -210,12 +203,11 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
     }
     const actualProjectedFiles = extractAffectedFiles(projectedDiff);
     const actualProjectedSet = new Set(actualProjectedFiles);
-    // Domain is the FULL requested list, not the diffable subset. When the
+    // Domain is the full requested list, not the diffable subset. When the
     // subset was used, any path filtered out upstream was invisible to this
-    // check by construction — which is exactly how a dropped deletion slipped
-    // through while the run reported success. A patch that does not do what
-    // its own file list claims is the one property a manifest must never get
-    // wrong, so an explicitly named path that produced no hunk is a refusal.
+    // check, which is how a dropped deletion slipped through while the run
+    // reported success. A patch must do what its own file list claims, so an
+    // explicitly named path that produced no hunk is a refusal.
     const noDiffFiles = requested.filter((file) => !actualProjectedSet.has(file));
     if (noDiffFiles.length > 0) {
         throw new InvalidArgumentError(`Refusing to re-export ${target.filename} with --files because ${noDiffFiles.length} requested path${noDiffFiles.length === 1 ? '' : 's'} produced no diff hunks (${noDiffFiles.join(', ')}). ` +
@@ -235,7 +227,16 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
     const patchQueueCtx = (await pathExists(paths.patches))
         ? await buildPatchQueueContext(paths.patches)
         : undefined;
-    await runPatchLint(paths.engine, actualProjectedFiles, projectedDiff, config, options.skipLint, patchQueueCtx, ignoreChecks, effectiveTier);
+    await runPatchLint({
+        engineDir: paths.engine,
+        filesAffected: actualProjectedFiles,
+        diffContent: projectedDiff,
+        config,
+        skipLint: options.skipLint,
+        patchQueueCtx,
+        ignoreChecks,
+        patchTier: effectiveTier,
+    });
     const conflicts = await runProjectedCrossPatchLint(paths.patches, target.filename, projectedDiff);
     const filesUpdates = buildFilesModeMetadataUpdates(actualProjectedFiles, options, effectiveLintIgnore, flagIgnoreSet);
     const manifest = await loadPatchesManifest(paths.patches);
@@ -273,23 +274,30 @@ export async function reExportFilesInPlace(paths, selectedPatches, options, conf
     // as the mutation (via the onCommitted hook) so two concurrent re-exports
     // cannot interleave records and a crash between mutation and append cannot
     // orphan the audit trail.
-    await updatePatchAndMetadata(paths.patches, target.filename, projectedDiff, filesUpdates, async () => {
-        await appendHistory(paths.patches, {
-            operation: 're-export-files',
-            args: {
-                filename: target.filename,
-                files: actualProjectedFiles,
-                previousFiles: target.filesAffected,
-                deletionsCaptured: deletedFiles,
-            },
-            ...(options.yes === true ? { yes: true } : {}),
-            ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
-            result: 'ok',
-        });
-    }, {
-        config,
-        command: 're-export --files',
-        forceUnsafe: options.forceUnsafe === true,
+    await updatePatchAndMetadata({
+        patchesDir: paths.patches,
+        filename: target.filename,
+        newContent: projectedDiff,
+        updates: filesUpdates,
+        onCommitted: async () => {
+            await appendHistory(paths.patches, {
+                operation: 're-export-files',
+                args: {
+                    filename: target.filename,
+                    files: actualProjectedFiles,
+                    previousFiles: target.filesAffected,
+                    deletionsCaptured: deletedFiles,
+                },
+                ...(options.yes === true ? { yes: true } : {}),
+                ...(options.forceUnsafe === true ? { unsafeOverride: true } : {}),
+                result: 'ok',
+            });
+        },
+        policyGate: {
+            config,
+            command: 're-export --files',
+            forceUnsafe: options.forceUnsafe === true,
+        },
     });
     success(`Re-exported ${target.filename}`);
     outro('Re-export complete');

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

@@ -1,41 +1,40 @@
 /**
  * Hoisted + cached lint context for `re-export`.
  *
- * Rebuilding the whole patch-queue context AND a fresh queue-wide checkJs
+ * Rebuilding the whole patch-queue context and a fresh queue-wide checkJs
  * TypeScript program for every patch costs tens of seconds of fixed setup
  * per patch, so an N-patch re-export pays it N times. This module:
  *
- * - builds the queue context and the {@link PerRunCheckJs} program
- *   controller ONCE per invocation (`buildReExportLintContext`) and slices
- *   per-patch findings out of it;
- * - reuses the existing per-patch lint RESULT cache
- *   (`.fireforge/lint-cache/per-patch-v1.json`) across invocations —
+ * - Builds the queue context and the {@link PerRunCheckJs} program
+ *   controller once per invocation (`buildReExportLintContext`) and slices
+ *   per-patch findings out of it.
+ * - Reuses the existing per-patch lint result cache
+ *   (`.fireforge/lint-cache/per-patch-v1.json`) across invocations, since
  *   re-export lints the identical input `lint --per-patch` does (the fresh
  *   `git diff HEAD` of the owned files), and the key already hashes engine
  *   HEAD, per-file content, patch body, config, shims, and ownership, so a
- *   repeat single re-export is a warm hit. `--no-cache` opts out; run-level
- *   checkJs globals are never cached and are emitted once per invocation;
- * - keeps the in-memory queue context honest after each write
+ *   repeat single re-export is a warm hit. `--no-cache` opts out. Run-level
+ *   checkJs globals are never cached and are emitted once per invocation.
+ * - Keeps the in-memory queue context honest after each write
  *   (`refreshQueueCtxEntry`), so later iterations of an `--all` run lint
  *   against the just-refreshed body instead of the stale one.
  */
-import { getProjectPaths, loadConfig } from '../core/config.js';
 import { type PatchQueueContext } from '../core/patch-lint.js';
 import { type PerPatchLintCacheFile } from '../core/patch-lint-cache.js';
 import type { PatchLintIssue, PatchMetadata } from '../types/commands/index.js';
-import type { FireForgeConfig } from '../types/config.js';
+import type { FireForgeConfig, ProjectPaths } from '../types/config.js';
 import { type PerRunCheckJs } from './lint-per-run-checkjs.js';
 /** Per-invocation lint context, built once and threaded through the loop. */
 export interface ReExportLintContext {
     projectRoot: string;
-    paths: ReturnType<typeof getProjectPaths>;
+    paths: ProjectPaths;
     config: FireForgeConfig;
-    /** Whole-queue context, built WITH config so the forward-import hints
-     * match `lint --per-patch`; undefined when no patches dir. */
+    /** Whole-queue context, built with config so the forward-import hints
+     * match `lint --per-patch`. Undefined when no patches dir. */
     patchQueueCtx: PatchQueueContext | undefined;
-    /** Queue-wide checkJs controller; undefined when checkJs is off. */
+    /** Queue-wide checkJs controller. Undefined when checkJs is off. */
     checkJs: PerRunCheckJs | undefined;
-    /** Per-patch result cache; undefined under `--no-cache`. */
+    /** Per-patch result cache. Undefined under `--no-cache`. */
     cache: PerPatchLintCacheFile | undefined;
     engineHeadSha: string | undefined;
     cacheDirty: boolean;
@@ -44,7 +43,7 @@ export interface ReExportLintContext {
     globalsEmitted: boolean;
 }
 /** Builds the once-per-invocation lint context. */
-export declare function buildReExportLintContext(projectRoot: string, paths: ReturnType<typeof getProjectPaths>, config: Awaited<ReturnType<typeof loadConfig>>, noCache: boolean): Promise<ReExportLintContext>;
+export declare function buildReExportLintContext(projectRoot: string, paths: ProjectPaths, config: FireForgeConfig, noCache: boolean): Promise<ReExportLintContext>;
 /** Fresh lint payload carried to the post-write cache store. */
 export interface ReExportLintResult {
     issues: PatchLintIssue[];
@@ -54,20 +53,20 @@ export interface ReExportLintResult {
     lintIgnore: string[];
 }
 /**
- * Lints one re-exported patch body using the hoisted context: cache hit →
- * replay the stored issues through the shared reporter (returns `null`);
- * miss → lint with the queue-wide program's pre-attributed slices (or a
+ * Lints one re-exported patch body using the hoisted context. A cache hit
+ * replays the stored issues through the shared reporter and returns `null`.
+ * A miss lints with the queue-wide program's pre-attributed slices (or a
  * per-patch build when the fresh diff creates files the hoisted program
- * never saw — the `--scan` adoption case) and return the payload for
+ * never saw, the `--scan` adoption case) and returns the payload for
  * {@link storeReExportLintResult}. Throws exactly like `runPatchLint` on
  * errors (unless `skipLint`).
  *
- * The cache key is built over the PROJECTED metadata (current
+ * The cache key is built over the projected metadata (current
  * filesAffected, merged lintIgnore, effective tier) so `--tier` /
- * `--lint-ignore` flags change the key. The entry itself is stored AFTER
- * the body write (the key hashes the on-disk `.patch` file, which this
- * very run is about to rewrite — a pre-write store could never match a
- * later run).
+ * `--lint-ignore` flags change the key. The entry itself is stored after
+ * the body write, because the key hashes the on-disk `.patch` file that
+ * this very run is about to rewrite, so a pre-write store could never
+ * match a later run.
  */
 export declare function lintReExportedPatch(args: {
     lintCtx: ReExportLintContext;
@@ -80,16 +79,16 @@ export declare function lintReExportedPatch(args: {
     patchTier?: 'branding';
 }): Promise<ReExportLintResult | null>;
 /**
- * Stores a fresh lint result AFTER the body write, keying against the
- * just-written `.patch` file and the refreshed queue context — the state
- * a later identical invocation will observe (call
+ * Stores a fresh lint result after the body write, keying against the
+ * just-written `.patch` file and the refreshed queue context, which is the
+ * state a later identical invocation will observe (call
  * {@link refreshQueueCtxEntry} first).
  */
 export declare function storeReExportLintResult(lintCtx: ReExportLintContext, patchFilename: string, projectedMetadata: PatchMetadata, existingFiles: string[], result: ReExportLintResult): Promise<void>;
 /**
  * Refreshes the in-memory queue entry for a just-rewritten patch so later
  * iterations (and later cache keys) lint against the new body instead of
- * the stale one. The on-disk write is the authority; this mirrors it.
+ * the stale one. The on-disk write is the authority. This mirrors it.
  */
 export declare function refreshQueueCtxEntry(lintCtx: ReExportLintContext, patchFilename: string, diffContent: string): void;
 /** Persists cache writes and reports reuse, once after the loop. */

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

@@ -2,25 +2,24 @@
 /**
  * Hoisted + cached lint context for `re-export`.
  *
- * Rebuilding the whole patch-queue context AND a fresh queue-wide checkJs
+ * Rebuilding the whole patch-queue context and a fresh queue-wide checkJs
  * TypeScript program for every patch costs tens of seconds of fixed setup
  * per patch, so an N-patch re-export pays it N times. This module:
  *
- * - builds the queue context and the {@link PerRunCheckJs} program
- *   controller ONCE per invocation (`buildReExportLintContext`) and slices
- *   per-patch findings out of it;
- * - reuses the existing per-patch lint RESULT cache
- *   (`.fireforge/lint-cache/per-patch-v1.json`) across invocations —
+ * - Builds the queue context and the {@link PerRunCheckJs} program
+ *   controller once per invocation (`buildReExportLintContext`) and slices
+ *   per-patch findings out of it.
+ * - Reuses the existing per-patch lint result cache
+ *   (`.fireforge/lint-cache/per-patch-v1.json`) across invocations, since
  *   re-export lints the identical input `lint --per-patch` does (the fresh
  *   `git diff HEAD` of the owned files), and the key already hashes engine
  *   HEAD, per-file content, patch body, config, shims, and ownership, so a
- *   repeat single re-export is a warm hit. `--no-cache` opts out; run-level
- *   checkJs globals are never cached and are emitted once per invocation;
- * - keeps the in-memory queue context honest after each write
+ *   repeat single re-export is a warm hit. `--no-cache` opts out. Run-level
+ *   checkJs globals are never cached and are emitted once per invocation.
+ * - Keeps the in-memory queue context honest after each write
  *   (`refreshQueueCtxEntry`), so later iterations of an `--all` run lint
  *   against the just-refreshed body instead of the stale one.
  */
-import { getProjectPaths, loadConfig } from '../core/config.js';
 import { buildPatchQueueContext, countNonBinaryDiffLines, detectNewFilesInDiff, lintExportedPatch, resolvePatchSizeTier, } from '../core/patch-lint.js';
 import { buildPerPatchLintCacheKey, getCachedPerPatchLintIssues, getPerPatchLintCacheHeadSha, loadPerPatchLintCache, savePerPatchLintCache, setCachedPerPatchLintIssues, } from '../core/patch-lint-cache.js';
 import { invalidateNewFileCreatorsCache } from '../core/patch-lint-cross.js';
@@ -63,26 +62,26 @@ function checkJsFilesInDiff(diffContent, checkJs) {
     return files;
 }
 /**
- * Lints one re-exported patch body using the hoisted context: cache hit →
- * replay the stored issues through the shared reporter (returns `null`);
- * miss → lint with the queue-wide program's pre-attributed slices (or a
+ * Lints one re-exported patch body using the hoisted context. A cache hit
+ * replays the stored issues through the shared reporter and returns `null`.
+ * A miss lints with the queue-wide program's pre-attributed slices (or a
  * per-patch build when the fresh diff creates files the hoisted program
- * never saw — the `--scan` adoption case) and return the payload for
+ * never saw, the `--scan` adoption case) and returns the payload for
  * {@link storeReExportLintResult}. Throws exactly like `runPatchLint` on
  * errors (unless `skipLint`).
  *
- * The cache key is built over the PROJECTED metadata (current
+ * The cache key is built over the projected metadata (current
  * filesAffected, merged lintIgnore, effective tier) so `--tier` /
- * `--lint-ignore` flags change the key. The entry itself is stored AFTER
- * the body write (the key hashes the on-disk `.patch` file, which this
- * very run is about to rewrite — a pre-write store could never match a
- * later run).
+ * `--lint-ignore` flags change the key. The entry itself is stored after
+ * the body write, because the key hashes the on-disk `.patch` file that
+ * this very run is about to rewrite, so a pre-write store could never
+ * match a later run.
  */
 export async function lintReExportedPatch(args) {
     const { lintCtx, patch, projectedMetadata, existingFiles, diffContent } = args;
     const { paths, config, patchQueueCtx, checkJs, cache } = lintCtx;
-    // Tier notice, identical to runPatchLint's head — surfaced on both the
-    // cached and fresh paths so the governing tier is never silent.
+    // Tier notice, identical to runPatchLint's head. It is surfaced on both
+    // the cached and fresh paths so the governing tier is never silent.
     const tierDecision = resolvePatchSizeTier(existingFiles, args.patchTier);
     if (tierDecision.tier === 'branding') {
         info(tierDecision.source === 'explicit'
@@ -127,8 +126,8 @@ export async function lintReExportedPatch(args) {
         }
         else {
             // Fresh `--scan` adoption created checkJs-relevant files the hoisted
-            // program has never seen — fall back to a per-patch build with the
-            // usual report scope so nothing is silently unchecked.
+            // program has never seen, so fall back to a per-patch build with the
+            // usual report scope and nothing is silently unchecked.
             lintOptions.checkJsReportScope = resolvePatchOwnedSysMjs(detectNewFilesInDiff(diffContent));
         }
     }
@@ -150,9 +149,9 @@ export async function lintReExportedPatch(args) {
     };
 }
 /**
- * Stores a fresh lint result AFTER the body write, keying against the
- * just-written `.patch` file and the refreshed queue context — the state
- * a later identical invocation will observe (call
+ * Stores a fresh lint result after the body write, keying against the
+ * just-written `.patch` file and the refreshed queue context, which is the
+ * state a later identical invocation will observe (call
  * {@link refreshQueueCtxEntry} first).
  */
 export async function storeReExportLintResult(lintCtx, patchFilename, projectedMetadata, existingFiles, result) {
@@ -169,13 +168,21 @@ export async function storeReExportLintResult(lintCtx, patchFilename, projectedM
         queueContext: patchQueueCtx,
         ...(lintCtx.engineHeadSha === undefined ? {} : { engineHeadSha: lintCtx.engineHeadSha }),
     });
-    setCachedPerPatchLintIssues(cache, patchFilename, cacheKey, result.issues, result.suppressed, result.lineCount, result.lintIgnore);
+    setCachedPerPatchLintIssues({
+        cache,
+        patchFilename,
+        key: cacheKey,
+        issues: result.issues,
+        suppressed: result.suppressed,
+        lineCount: result.lineCount,
+        lintIgnore: result.lintIgnore,
+    });
     lintCtx.cacheDirty = true;
 }
 /**
  * Refreshes the in-memory queue entry for a just-rewritten patch so later
  * iterations (and later cache keys) lint against the new body instead of
- * the stale one. The on-disk write is the authority; this mirrors it.
+ * the stale one. The on-disk write is the authority. This mirrors it.
  */
 export function refreshQueueCtxEntry(lintCtx, patchFilename, diffContent) {
     const ctx = lintCtx.patchQueueCtx;
@@ -191,7 +198,7 @@ export function refreshQueueCtxEntry(lintCtx, patchFilename, diffContent) {
     const modifiedFileAdditions = new Map();
     for (const [file, lines] of addedLinesByFile) {
         if (newFilePaths.has(file)) {
-            // A created file's content IS its added lines.
+            // A created file's content is its added lines.
             newFiles.set(file, lines.join('\n'));
         }
         else {

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

@@ -11,7 +11,7 @@ export interface NormalizedReExportArguments {
  * `re-export <patch> --files`. Commander's `--files <paths>` consumes one
  * comma-separated value, so `re-export 006-x --files a/b.js c/d.js` parks
  * `c/d.js` in the positional patches and fails with "--files operates on
- * exactly one target patch" — pointing at the wrong argument. When every
+ * exactly one target patch", pointing at the wrong argument. When every
  * positional beyond the first looks like a file path, fold them into the
  * file list.
  */

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

@@ -14,7 +14,7 @@ function looksLikeFilePath(value) {
  * `re-export <patch> --files`. Commander's `--files <paths>` consumes one
  * comma-separated value, so `re-export 006-x --files a/b.js c/d.js` parks
  * `c/d.js` in the positional patches and fails with "--files operates on
- * exactly one target patch" — pointing at the wrong argument. When every
+ * exactly one target patch", pointing at the wrong argument. When every
  * positional beyond the first looks like a file path, fold them into the
  * file list.
  */

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

@@ -3,7 +3,7 @@
  *
  * Split out of `re-export.ts`, which was otherwise over the per-file line
  * cap. The split direction matches the existing `re-export-scan.ts` /
- * `re-export-options.ts` boundary; folding `re-export-files.ts` back into
+ * `re-export-options.ts` boundary. Folding `re-export-files.ts` back into
  * the orchestrator would go the wrong way.
  */
 import { Command } from 'commander';

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

@@ -4,7 +4,7 @@
  *
  * Split out of `re-export.ts`, which was otherwise over the per-file line
  * cap. The split direction matches the existing `re-export-scan.ts` /
- * `re-export-options.ts` boundary; folding `re-export-files.ts` back into
+ * `re-export-options.ts` boundary. Folding `re-export-files.ts` back into
  * the orchestrator would go the wrong way.
  */
 import { Command, Option } from 'commander';

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

@@ -30,7 +30,7 @@ export declare function confirmBroadScanAdditions(args: {
 }): Promise<boolean>;
 /**
  * Refuses scan adoptions whose candidate files import modules created by
- * LATER patches. Modeled on the `re-export --files` cross-patch
+ * 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.

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

@@ -6,6 +6,7 @@ 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';
@@ -56,10 +57,10 @@ async function scanPatchFiles(args) {
             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
+    // 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
+    // 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);
@@ -77,7 +78,7 @@ async function scanPatchFilesTargeted(args) {
     // 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.
+    // 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');
@@ -98,12 +99,12 @@ async function scanPatchFilesTargeted(args) {
     return reportScanResult(currentFilesAffected, patchFilename, isDryRun, added.sort(), removed);
 }
 /**
- * Paths that have genuinely left the patch's ownership: absent from disk AND
+ * 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.
+ * 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
+ * `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.
  */
@@ -135,14 +136,14 @@ export async function confirmBroadScanAdditions(args) {
     if (isDryRun || yes || !scanAdditionsNeedConfirmation(added))
         return true;
     const dirCount = new Set(added.map((f) => dirname(f))).size;
-    warn(`${patchFilename}: --scan would add ${String(added.length)} file(s) that span ${String(dirCount)} director${dirCount === 1 ? 'y' : 'ies'}. ` +
+    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 ${String(added.length)} newly discovered file(s)?`,
+        message: `Proceed and broaden ${patchFilename} with ${added.length} newly discovered file(s)?`,
         initialValue: false,
     });
     if (isCancel(confirmed) || !confirmed) {
@@ -160,7 +161,7 @@ function scanAdditionsNeedConfirmation(added) {
 }
 /**
  * Refuses scan adoptions whose candidate files import modules created by
- * LATER patches. Modeled on the `re-export --files` cross-patch
+ * 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.
@@ -177,6 +178,7 @@ export async function assertScanAdoptionsHaveNoForwardImports(args) {
     if (!candidateDiff.trim())
         return;
     const candidateNewFiles = buildNewFileTextProjection(candidateDiff);
+    const candidateCreations = detectNewFilesInDiff(candidateDiff);
     const candidateAdditions = buildModifiedFileAdditionsFromDiff(candidateDiff);
     const baseCtx = await buildPatchQueueContext(patchesDir);
     const projectedEntries = baseCtx.entries.map((entry) => {
@@ -186,6 +188,7 @@ export async function assertScanAdoptionsHaveNoForwardImports(args) {
             ...entry,
             diff: `${entry.diff}\n${candidateDiff}`,
             newFiles: new Map([...entry.newFiles, ...candidateNewFiles]),
+            createdFiles: new Set([...entry.createdFiles, ...candidateCreations]),
             modifiedFileAdditions: new Map([...entry.modifiedFileAdditions, ...candidateAdditions]),
         };
     });

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

@@ -4,17 +4,36 @@
  * loop calls {@link reExportSinglePatchWithIndexLockRetry} per selected
  * patch.
  */
-import { getProjectPaths } from '../core/config.js';
 import type { PatchesManifest, PatchMetadata, ReExportOptions } from '../types/commands/index.js';
-import type { FireForgeConfig } from '../types/config.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
+ * 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(patch: PatchMetadata, paths: ReturnType<typeof getProjectPaths>, manifest: PatchesManifest, options: ReExportOptions, isDryRun: boolean, config: FireForgeConfig, adjacentCtx: AdjacentUnmanagedContext, driftCtx: ForeignDriftContext, lintCtx: ReExportLintContext): Promise<boolean>;
+export declare function reExportSinglePatchWithIndexLockRetry(args: ReExportSinglePatchArgs): Promise<boolean>;