@hominis/fireforge 0.43.0 → 0.44.0

package/dist/src/core/{manifest-rules.js → moz-manifest-rules.js}

@@ -2,9 +2,10 @@
 import { basename, join } from 'node:path';
 import { GeneralError, InvalidArgumentError } from '../errors/base.js';
 import { pathExists, readText } from '../utils/fs.js';
+import { warn } from '../utils/logger.js';
 import { escapeRegex } from '../utils/regex.js';
 import { getProjectPaths, loadConfig } from './config.js';
-import { registerBrowserContent, registerFireForgeModule, registerSharedCSS, registerTestManifest, registerToolkitWidget, } from './manifest-register.js';
+import { registerBrowserContent, registerFireForgeModule, registerSharedCSS, registerTestManifest, registerToolkitWidget, } from './moz-manifest-register.js';
 import { isXpcshellTestRegistered, registerXpcshellTest } from './register-xpcshell-test.js';
 /**
  * Returns manifest registration rules for the supported engine file
@@ -21,64 +22,65 @@ export function getRules(binaryName, createManifest = false) {
             isRegistered: (engineDir, fileName) => isSharedCSSRegistered(engineDir, fileName),
             register: (engineDir, after, dryRun, fileName) => registerSharedCSS(engineDir, fileName, after, dryRun),
             extractArgs: (m) => [m[1] ?? ''],
+            supportsAfter: true,
         },
         {
             // `.inc.xhtml` fragments under browser/base/content/ are deliberately
             // excluded: they are consumed via `#include` from a registered chrome
-            // document (typically browser.xhtml) and do not get their own
-            // packaged chrome URI. Before this carve-out, `status` flagged every
-            // wired fragment as "potentially unregistered" and `register --dry-run`
-            // proposed a bogus jar.mn entry. The lookahead blocks the match so
-            // `getUnregistrableAdvice` gets a chance to emit the correct
-            // guidance for the `.inc.xhtml` case.
+            // document (typically browser.xhtml) and do not get their own packaged
+            // chrome URI. Without the carve-out, `status` flags every wired
+            // fragment as "potentially unregistered" and `register --dry-run`
+            // proposes a bogus jar.mn entry. The lookahead blocks the match so
+            // `getUnregistrableAdvice` can emit the correct guidance instead.
             //
             // Test implementation files under `browser/base/content/test/` are
             // also excluded: they belong in the nearest `browser.toml` manifest,
-            // not in jar.mn. 2026-04-23 eval 2: `status --unmanaged` proposed
-            // `fireforge register browser/base/content/test/<dir>/browser_*.js`
-            // which would have clutter-registered a test file as browser
-            // chrome content. The negative lookahead routes those paths to
-            // `getUnregistrableAdvice`, which returns the correct
-            // browser.toml-centric guidance.
+            // not in jar.mn. The negative lookahead routes those paths to
+            // `getUnregistrableAdvice`, which returns browser.toml-centric
+            // guidance rather than proposing a jar.mn entry for a test file.
             pattern: /^browser\/base\/content\/(?!.+\.inc\.xhtml$)(?!test\/)(.+\.(?:js|mjs|xhtml|css))$/,
             isRegistered: (engineDir, fileName) => isBrowserContentRegistered(engineDir, fileName),
             register: (engineDir, after, dryRun, fileName) => registerBrowserContent(engineDir, fileName, after, undefined, dryRun),
             extractArgs: (m) => [m[1] ?? ''],
+            supportsAfter: true,
         },
         {
             // Fork-owned browser.toml manifests at ARBITRARY depth under
-            // browser/base/content/test/ (0.34.0 field report: only one level
-            // was supported, rejecting nested browser-chrome manifests).
+            // browser/base/content/test/ — a one-level pattern rejects nested
+            // browser-chrome manifests.
             pattern: /^browser\/base\/content\/test\/((?:[^/]+\/)*[^/]+)\/browser\.toml$/,
             isRegistered: (_engineDir, testDir) => isTestManifestRegistered(_engineDir, testDir),
             register: (_engineDir, _after, dryRun, testDir) => registerTestManifest(_engineDir, testDir, dryRun),
             extractArgs: (m) => [m[1] ?? ''],
+            supportsAfter: false,
         },
         {
             pattern: new RegExp(`^browser/modules/${escapeRegex(binaryName)}/(.+\\.sys\\.mjs)$`),
             isRegistered: (_engineDir, fileName) => isFireForgeModuleRegistered(_engineDir, fileName, moduleDir),
             register: (_engineDir, _after, dryRun, fileName) => registerFireForgeModule(_engineDir, fileName, moduleDir, dryRun, createManifest),
             extractArgs: (m) => [m[1] ?? ''],
+            supportsAfter: false,
         },
         {
             pattern: /^toolkit\/content\/widgets\/([^/]+)\/(.+\.(?:mjs|css))$/,
             isRegistered: (_engineDir, tagName, fileName) => isToolkitWidgetRegistered(_engineDir, tagName, fileName),
             register: (_engineDir, _after, dryRun, tagName, fileName) => registerToolkitWidget(_engineDir, tagName, fileName, dryRun),
             extractArgs: (m) => [m[1] ?? '', m[2] ?? ''],
+            supportsAfter: false,
         },
         {
-            // xpcshell test files (0.34.0 field report: rejected as "Unknown
-            // file pattern"). Any `test_*.js` outside browser/base/content/test/
-            // (which stays browser-chrome territory with its browser.toml
-            // guidance) registers into the directory's xpcshell.toml; with
-            // --create-manifest a missing manifest is scaffolded and wired via
-            // XPCSHELL_TESTS_MANIFESTS.
+            // xpcshell test files. Any `test_*.js` outside
+            // browser/base/content/test/ (which stays browser-chrome territory
+            // with its browser.toml guidance) registers into the directory's
+            // xpcshell.toml; with --create-manifest a missing manifest is
+            // scaffolded and wired via XPCSHELL_TESTS_MANIFESTS.
             pattern: /^(?!browser\/base\/content\/test\/)(.+)\/(test_[^/]+\.js)$/,
             isRegistered: (engineDir, dirRel, fileName) => isXpcshellTestRegistered(engineDir, dirRel, fileName),
             register: (engineDir, _after, dryRun, dirRel, fileName) => registerXpcshellTest(engineDir, dirRel, fileName, dryRun, createManifest),
             // Both groups are guaranteed by the pattern; slice avoids dead
             // fallback branches.
             extractArgs: (m) => m.slice(1, 3),
+            supportsAfter: false,
         },
     ];
 }
@@ -166,9 +168,8 @@ function getUnregistrableAdvice(filePath) {
     // scaffold intentionally does NOT auto-register — wiring
     // `XPCSHELL_TESTS_MANIFESTS` requires a deliberate choice about which
     // moz.build should own the entry. `register` surfaces that same guidance
-    // instead of falling through to browser.toml-centric advice, which was
-    // the eval finding (operator saw "register browser.toml" hint for a
-    // path that was xpcshell-shaped and contained no browser.toml).
+    // instead of falling through to browser.toml-centric advice for a path
+    // that is xpcshell-shaped and contains no browser.toml.
     if (filePath.endsWith('/xpcshell.toml')) {
         return (`xpcshell.toml manifests are not auto-registered by "fireforge register". ` +
             `Add "XPCSHELL_TESTS_MANIFESTS += ['${basename(filePath)}']" to the ` +
@@ -241,6 +242,12 @@ export async function registerFile(root, filePath, dryRun = false, after, option
         const match = normalizedPath.match(rule.pattern);
         if (match) {
             const args = rule.extractArgs(match);
+            if (after !== undefined && !rule.supportsAfter) {
+                // Say so rather than inserting alphabetically and letting the
+                // operator believe their placement was honoured.
+                warn(`--after is not supported for ${normalizedPath}: this manifest is ` +
+                    'kept in sorted order, so the entry was inserted alphabetically.');
+            }
             return rule.register(engineDir, after, dryRun, ...args);
         }
     }

package/dist/src/core/{manifest-tokenizers.d.ts → moz-manifest-tokenizers.d.ts}

@@ -27,11 +27,9 @@ export declare function tokenizeJarMn(lines: string[]): JarMnToken[];
  * Tokenizes a moz.build Python list block, returning the tokens and their
  * line range within the file.
  *
- * Supports both multi-line lists (the common shape) and single-line
- * empty lists of the form `EXTRA_JS_MODULES += []` — the eval-2 finding
- * case where a freshly-scaffolded module directory's `moz.build`
- * started with an empty list and the tokenizer returned `null`,
- * leaving `register` unable to add the first entry.
+ * Supports both multi-line lists (the common shape) and single-line empty
+ * lists of the form `EXTRA_JS_MODULES += []`, which a freshly-scaffolded
+ * module directory's `moz.build` can start with.
  */
 export declare function tokenizeMozBuildList(lines: string[], listPattern: RegExp): {
     tokens: MozBuildToken[];

package/dist/src/core/{manifest-tokenizers.js → moz-manifest-tokenizers.js}

@@ -45,11 +45,9 @@ export function tokenizeJarMn(lines) {
  * Tokenizes a moz.build Python list block, returning the tokens and their
  * line range within the file.
  *
- * Supports both multi-line lists (the common shape) and single-line
- * empty lists of the form `EXTRA_JS_MODULES += []` — the eval-2 finding
- * case where a freshly-scaffolded module directory's `moz.build`
- * started with an empty list and the tokenizer returned `null`,
- * leaving `register` unable to add the first entry.
+ * Supports both multi-line lists (the common shape) and single-line empty
+ * lists of the form `EXTRA_JS_MODULES += []`, which a freshly-scaffolded
+ * module directory's `moz.build` can start with.
  */
 export function tokenizeMozBuildList(lines, listPattern) {
     const tokens = [];
@@ -60,16 +58,15 @@ export function tokenizeMozBuildList(lines, listPattern) {
         if (startLine === -1) {
             if (listPattern.test(raw)) {
                 // Single-line empty-list handling: a fresh scaffold sometimes
-                // writes `EXTRA_JS_MODULES += []` on one line. The pre-fix
-                // tokenizer returned `null` because it never saw a line
-                // starting with `]`, which stranded `register` with a "Could
-                // not find module list section" error against the documented
-                // browser/modules/<fork>/ scaffold (eval 2).
+                // writes `EXTRA_JS_MODULES += []` on one line, which a tokenizer
+                // looking for a line starting with `]` never closes — leaving
+                // `register` with a "Could not find module list section" error
+                // against the documented browser/modules/<fork>/ scaffold.
                 //
                 // The in-place split rewrites the single-line form into the
                 // canonical multi-line shape so the caller's
-                // `lines.splice(insertIndex, 0, entry)` lands inside the list
-                // body. The tokens are emitted to mirror the new structure.
+                // `lines.splice(insertIndex, 0, entry)` lands inside the list body.
+                // The tokens are emitted to mirror the new structure.
                 const singleLineMatch = /^([^[]*\[)\s*\]\s*$/.exec(raw);
                 if (singleLineMatch) {
                     const openPart = singleLineMatch[1] ?? '';

package/dist/src/core/ownership-table.d.ts

@@ -16,30 +16,28 @@ interface StatusFile {
     file: string;
 }
 /**
- * Builds the flat ownership table from the manifest, worktree status, and
- * the duplicate-new-file-creation map produced by cross-patch lint.
+ * Builds the flat ownership table from the manifest, worktree status, and the
+ * duplicate-new-file-creation map produced by cross-patch lint.
  *
  * Populated from three sources:
  *
- *   1. Every path in every patch's `filesAffected` — so managed paths
- *      show up even when they are not currently modified on disk.
+ *   1. Every path in every patch's `filesAffected` — so managed paths show up
+ *      even when they are not currently modified on disk.
  *   2. Any worktree status entries not claimed by any patch (flagged as
  *      `unmanaged`).
- *   3. Paths created by more than one patch in `new file mode`,
- *      surfaced as ownership conflicts with
- *      `conflictReason = 'duplicate-create'`. This is the alignment
- *      fix between `status --ownership` and `fireforge verify`: a
- *      queue that `verify` rejects for duplicate `/dev/null → b/foo.js`
- *      creations was previously reported as clean here because the
- *      check only walked `filesAffected`, not the patch bodies.
+ *   3. Paths created by more than one patch in `new file mode`, surfaced as
+ *      ownership conflicts with `conflictReason = 'duplicate-create'`. This
+ *      is what keeps `status --ownership` aligned with `fireforge verify`:
+ *      walking only `filesAffected` reports a queue clean that `verify`
+ *      rejects for duplicate `/dev/null → b/foo.js` creations.
  *
- * A path claimed by more than one patch (either via `filesAffected` or
- * as a duplicate creation) is flagged as `conflict` with the origin
- * recorded in `conflictReason` so the output can disambiguate.
+ * A path claimed by more than one patch (either via `filesAffected` or as a
+ * duplicate creation) is flagged as `conflict` with the origin recorded in
+ * `conflictReason` so the output can disambiguate.
  *
  * @param manifestPatches - Manifest rows, each with its `filesAffected`
- * @param worktreeFiles - Raw worktree status entries; untracked and
- *   modified both acceptable
+ * @param worktreeFiles - Raw worktree status entries; untracked and modified
+ *   both acceptable
  * @param newFileCreatorsByPath - Map produced by
  *   {@link import('../core/patch-lint.js').collectNewFileCreatorsByPath};
  *   paths with a `.length > 1` owner list become duplicate-create conflicts

package/dist/src/core/ownership-table.js

@@ -1,30 +1,28 @@
 import { info } from '../utils/logger.js';
 import { buildPatchClaims } from './status-classify.js';
 /**
- * Builds the flat ownership table from the manifest, worktree status, and
- * the duplicate-new-file-creation map produced by cross-patch lint.
+ * Builds the flat ownership table from the manifest, worktree status, and the
+ * duplicate-new-file-creation map produced by cross-patch lint.
  *
  * Populated from three sources:
  *
- *   1. Every path in every patch's `filesAffected` — so managed paths
- *      show up even when they are not currently modified on disk.
+ *   1. Every path in every patch's `filesAffected` — so managed paths show up
+ *      even when they are not currently modified on disk.
  *   2. Any worktree status entries not claimed by any patch (flagged as
  *      `unmanaged`).
- *   3. Paths created by more than one patch in `new file mode`,
- *      surfaced as ownership conflicts with
- *      `conflictReason = 'duplicate-create'`. This is the alignment
- *      fix between `status --ownership` and `fireforge verify`: a
- *      queue that `verify` rejects for duplicate `/dev/null → b/foo.js`
- *      creations was previously reported as clean here because the
- *      check only walked `filesAffected`, not the patch bodies.
+ *   3. Paths created by more than one patch in `new file mode`, surfaced as
+ *      ownership conflicts with `conflictReason = 'duplicate-create'`. This
+ *      is what keeps `status --ownership` aligned with `fireforge verify`:
+ *      walking only `filesAffected` reports a queue clean that `verify`
+ *      rejects for duplicate `/dev/null → b/foo.js` creations.
  *
- * A path claimed by more than one patch (either via `filesAffected` or
- * as a duplicate creation) is flagged as `conflict` with the origin
- * recorded in `conflictReason` so the output can disambiguate.
+ * A path claimed by more than one patch (either via `filesAffected` or as a
+ * duplicate creation) is flagged as `conflict` with the origin recorded in
+ * `conflictReason` so the output can disambiguate.
  *
  * @param manifestPatches - Manifest rows, each with its `filesAffected`
- * @param worktreeFiles - Raw worktree status entries; untracked and
- *   modified both acceptable
+ * @param worktreeFiles - Raw worktree status entries; untracked and modified
+ *   both acceptable
  * @param newFileCreatorsByPath - Map produced by
  *   {@link import('../core/patch-lint.js').collectNewFileCreatorsByPath};
  *   paths with a `.length > 1` owner list become duplicate-create conflicts

package/dist/src/core/parser-fallback.d.ts

@@ -3,13 +3,27 @@ export interface ParserFallbackEvent {
     reason: string;
 }
 /** Returns recorded parser fallback events without clearing the event buffer. */
-export declare function peekParserFallbackEvents(): ParserFallbackEvent[];
 /** Returns and clears the recorded parser fallback events. */
 export declare function consumeParserFallbackEvents(): ParserFallbackEvent[];
 /**
  * Result of a parser-with-fallback invocation, carrying both the computed
  * value and metadata about which code path produced it.
  */
+/**
+ * The `rethrowIf` predicate every AST-primary caller wants.
+ *
+ * Rethrows internal-invariant `GeneralError`s ("Unexpected empty …array"):
+ * those are programming bugs, and retrying the legacy scanner cannot fix a
+ * broken invariant — it just buries the stack. Everything else still falls
+ * back, which is load-bearing: the AST path raises a raw acorn SyntaxError
+ * on chrome sources acorn cannot parse (preprocessor directives), and
+ * BuildError when the file's shape is unexpected. Both are exactly what the
+ * legacy scanner is here to handle.
+ *
+ * @param error - The error the primary parser threw
+ * @returns True when the error must propagate instead of falling back
+ */
+export declare function isInternalInvariantFailure(error: unknown): boolean;
 export interface ParserResult<T> {
     /** The computed value (from either the primary or fallback path). */
     value: T;

package/dist/src/core/parser-fallback.js

@@ -1,17 +1,36 @@
 // SPDX-License-Identifier: EUPL-1.2
+import { GeneralError } from '../errors/base.js';
 import { toError } from '../utils/errors.js';
 import { warn } from '../utils/logger.js';
 const parserFallbackEvents = [];
 /** Returns recorded parser fallback events without clearing the event buffer. */
-export function peekParserFallbackEvents() {
-    return [...parserFallbackEvents];
-}
 /** Returns and clears the recorded parser fallback events. */
 export function consumeParserFallbackEvents() {
     const events = [...parserFallbackEvents];
     parserFallbackEvents.length = 0;
     return events;
 }
+/**
+ * Result of a parser-with-fallback invocation, carrying both the computed
+ * value and metadata about which code path produced it.
+ */
+/**
+ * The `rethrowIf` predicate every AST-primary caller wants.
+ *
+ * Rethrows internal-invariant `GeneralError`s ("Unexpected empty …array"):
+ * those are programming bugs, and retrying the legacy scanner cannot fix a
+ * broken invariant — it just buries the stack. Everything else still falls
+ * back, which is load-bearing: the AST path raises a raw acorn SyntaxError
+ * on chrome sources acorn cannot parse (preprocessor directives), and
+ * BuildError when the file's shape is unexpected. Both are exactly what the
+ * legacy scanner is here to handle.
+ *
+ * @param error - The error the primary parser threw
+ * @returns True when the error must propagate instead of falling back
+ */
+export function isInternalInvariantFailure(error) {
+    return error instanceof GeneralError;
+}
 /**
  * Wraps a primary (AST/tokenizer) parser with a legacy (regex/line-based)
  * fallback. If the primary throws, a warning is logged and the fallback is

package/dist/src/core/patch-apply-fuzz.d.ts

@@ -2,21 +2,19 @@
  * Fuzz-like patch application with escalating context reduction.
  *
  * Tries an exact `git apply` first, then retries with git's real
- * drift-tolerance knob: `-C<n>` (reduced context matching). `git apply`
- * has NO `--fuzz` option — that flag belongs to GNU `patch(1)`. The
- * original implementation passed `--fuzz=N`, which git rejects with a
- * usage error (exit 129) that the escalation loop swallowed, so every
- * "fuzzy" attempt silently failed and patches that would have applied
- * with context drift were reported as hard conflicts (2026-07-05 review,
- * finding H1; verified against git 2.50). If all context-reduction levels
- * fail, falls through to `git apply --reject` so the user gets `.rej`
- * files for manual resolution.
+ * drift-tolerance knob: `-C<n>` (reduced context matching). `git apply` has
+ * NO `--fuzz` option — that flag belongs to GNU `patch(1)`, and passing it
+ * makes git exit 129 with a usage error that an escalation loop will happily
+ * swallow, so every "fuzzy" attempt silently fails and patches that would
+ * have applied with context drift are reported as hard conflicts. If all
+ * context-reduction levels fail, falls through to `git apply --reject` so
+ * the user gets `.rej` files for manual resolution.
  *
  * Semantics note: GNU fuzz *fuzzily matches* context; `-C<n>` *ignores*
  * outer context lines instead. Step k maps to `-C(3-k)` (git's default
- * context width is 3), so the final step `-C0` matches on line positions
- * and -/+ content alone — the rough analogue of GNU `--fuzz=3` on a
- * 3-context patch.
+ * context width is 3), so the final step `-C0` matches on line positions and
+ * -/+ content alone — the rough analogue of GNU `--fuzz=3` on a 3-context
+ * patch.
  */
 export interface FuzzyApplyResult {
     /** Whether the patch was applied successfully. */

package/dist/src/core/patch-apply-fuzz.js

@@ -3,21 +3,19 @@
  * Fuzz-like patch application with escalating context reduction.
  *
  * Tries an exact `git apply` first, then retries with git's real
- * drift-tolerance knob: `-C<n>` (reduced context matching). `git apply`
- * has NO `--fuzz` option — that flag belongs to GNU `patch(1)`. The
- * original implementation passed `--fuzz=N`, which git rejects with a
- * usage error (exit 129) that the escalation loop swallowed, so every
- * "fuzzy" attempt silently failed and patches that would have applied
- * with context drift were reported as hard conflicts (2026-07-05 review,
- * finding H1; verified against git 2.50). If all context-reduction levels
- * fail, falls through to `git apply --reject` so the user gets `.rej`
- * files for manual resolution.
+ * drift-tolerance knob: `-C<n>` (reduced context matching). `git apply` has
+ * NO `--fuzz` option — that flag belongs to GNU `patch(1)`, and passing it
+ * makes git exit 129 with a usage error that an escalation loop will happily
+ * swallow, so every "fuzzy" attempt silently fails and patches that would
+ * have applied with context drift are reported as hard conflicts. If all
+ * context-reduction levels fail, falls through to `git apply --reject` so
+ * the user gets `.rej` files for manual resolution.
  *
  * Semantics note: GNU fuzz *fuzzily matches* context; `-C<n>` *ignores*
  * outer context lines instead. Step k maps to `-C(3-k)` (git's default
- * context width is 3), so the final step `-C0` matches on line positions
- * and -/+ content alone — the rough analogue of GNU `--fuzz=3` on a
- * 3-context patch.
+ * context width is 3), so the final step `-C0` matches on line positions and
+ * -/+ content alone — the rough analogue of GNU `--fuzz=3` on a 3-context
+ * patch.
  */
 import { InvalidArgumentError } from '../errors/base.js';
 import { verbose } from '../utils/logger.js';
@@ -84,16 +82,15 @@ export async function applyPatchWithFuzz(patchPath, engineDir, maxFuzz = 3) {
 /**
  * Extracts `.rej` file paths from `git apply --reject` stderr.
  *
- * Git's actual output shape (verified against git 2.50):
+ * Git's output shape:
  *
  *   Applying patch f.txt with 1 reject...
  *   Rejected hunk #1.
  *
- * The reject file is `<file>.rej` next to the target. The previous regex
- * (`Rejected hunk.*to (.+\.rej)`) targeted GNU `patch(1)`'s "saving
- * rejects to file X.rej" phrasing, which git never prints — so
- * `rejectFiles` was always empty and the conflict-summary ".rej files
- * created" hint never fired.
+ * The reject file is `<file>.rej` next to the target. Matching GNU
+ * `patch(1)`'s "saving rejects to file X.rej" phrasing instead — which git
+ * never prints — leaves `rejectFiles` always empty and the
+ * conflict-summary ".rej files created" hint never fires.
  */
 function extractRejectFiles(stderr) {
     const rejectFiles = [];

package/dist/src/core/patch-apply.d.ts

@@ -2,30 +2,12 @@
  * Patch orchestration — coordinates patch discovery, application, and validation.
  * Pure parsing, content transformation, and lock management are in separate modules.
  */
-import type { ImportSummary, PatchInfo, PatchMetadata, PatchResult } from '../types/commands/index.js';
+import type { ImportSummary, PatchInfo, PatchMetadata } from '../types/commands/index.js';
 export { PatchError } from '../errors/patch.js';
 export { countPatches, discoverPatches, getAllTargetFilesFromPatch, getTargetFileFromPatch, isNewFilePatch, } from './patch-files.js';
 export { withPatchDirectoryLock } from './patch-lock.js';
 export { extractAffectedFiles, extractOrder, isNewFileInPatch } from './patch-parse.js';
 export { applyPatchToContent, extractNewFileContent } from './patch-transform.js';
-/**
- * Applies all patches in order. Rolls back all successfully applied
- * patches when one fails so the engine directory stays clean.
- * @param patchesDir - Path to the patches directory
- * @param engineDir - Path to the engine directory
- * @returns Results for each patch
- */
-export declare function applyPatches(patchesDir: string, engineDir: string): Promise<PatchResult[]>;
-/**
- * Validates that all patches can be applied.
- * @param patchesDir - Path to the patches directory
- * @param engineDir - Path to the engine directory
- * @returns Validation results
- */
-export declare function validatePatches(patchesDir: string, engineDir: string): Promise<{
-    valid: boolean;
-    errors: string[];
-}>;
 /**
  * Options for {@link applyPatchesWithContinue}.
  */
@@ -49,17 +31,14 @@ export interface ApplyPatchesOptions {
  *   1. **Exact filename** — `005-foo.patch`. Matches only that filename.
  *   2. **Filename without extension** — `005-foo`. Matches `005-foo.patch`.
  *   3. **Bare numeric ordinal** — `5` or `005`. Matches the patch whose
- *      order prefix parses to the same integer (so `5` and `005` both
- *      match `005-foo.patch`, and `05` matches too because parseInt
- *      normalizes leading zeros).
+ *      order prefix parses to the same integer (so `5` and `005` both match
+ *      `005-foo.patch`, and `05` matches too because parseInt normalizes
+ *      leading zeros).
  *
- * A purely-numeric identifier is treated **only** as an ordinal: it does
- * not also match a filename that happens to literally equal the digits.
- * That would require a patch literally named `5` or `005` — which would
- * collide with the filename prefix anyway — and we prefer the explicit
- * ordinal interpretation. The earlier form's `patchFilename === needle`
- * short-circuit was kept behind the numeric gate so the match stays
- * single-meaning per identifier.
+ * A purely-numeric identifier is treated **only** as an ordinal: it does not
+ * also match a filename that happens to literally equal the digits. That
+ * would require a patch literally named `5` or `005`, which would collide
+ * with the filename prefix anyway.
  */
 export declare function matchesUntilFilename(patchFilename: string, needle: string): boolean;
 /**
@@ -88,10 +67,10 @@ export interface PatchedContentContext {
 }
 /**
  * Builds a batched patched-content context that loads the manifest and
- * discovers patch files ONCE for many lookups, and memoizes each patch
- * body read across the batch. The old per-call helper re-ran
- * `loadPatchesManifest` + `discoverPatches` and re-read every affecting
- * patch body for every file — O(dirtyFiles × patches) redundant IO when
- * classifying a broad engine edit session during `status` or `import`.
+ * discovers patch files ONCE for many lookups, and memoizes each patch body
+ * read across the batch. A per-call helper re-runs `loadPatchesManifest` +
+ * `discoverPatches` and re-reads every affecting patch body for every file —
+ * O(dirtyFiles × patches) redundant IO when classifying a broad engine edit
+ * session during `status` or `import`.
  */
 export declare function createPatchedContentContext(patchesDir: string, engineDir: string): Promise<PatchedContentContext>;

package/dist/src/core/patch-apply.js

@@ -10,7 +10,6 @@ import { toError } from '../utils/errors.js';
 import { pathExists, readText, writeText } from '../utils/fs.js';
 import { verbose } from '../utils/logger.js';
 import { isContainedRelativePath } from '../utils/paths.js';
-import { exec } from '../utils/process.js';
 import { applyPatchIdempotent, reversePatch } from './git.js';
 import { getFileContentFromHead } from './git-file-ops.js';
 import { discoverPatches } from './patch-files.js';
@@ -25,13 +24,14 @@ export { extractAffectedFiles, extractOrder, isNewFileInPatch } from './patch-pa
 export { applyPatchToContent, extractNewFileContent } from './patch-transform.js';
 /**
  * Applies a single patch.
+ *
  * @param patch - Patch info
  * @param engineDir - Path to the engine directory
  * @param protectedFiles - Files touched by patches already applied in the
  *   current run; the idempotent-recovery reset must not wipe them (see
- *   applyPatchIdempotent). Overlapping queues (`--allow-overlap`) share
- *   files between patches, and a later patch's recovery used to reset the
- *   shared file to HEAD — silently discarding the earlier patch's changes.
+ *   applyPatchIdempotent). Overlapping queues (`--allow-overlap`) share files
+ *   between patches, and resetting a shared file to HEAD during a later
+ *   patch's recovery silently discards the earlier patch's changes.
  * @returns Patch result
  */
 async function applySinglePatch(patch, engineDir, protectedFiles) {
@@ -148,63 +148,6 @@ async function rollbackPatches(results, engineDir) {
         }
     }
 }
-/**
- * Applies all patches in order. Rolls back all successfully applied
- * patches when one fails so the engine directory stays clean.
- * @param patchesDir - Path to the patches directory
- * @param engineDir - Path to the engine directory
- * @returns Results for each patch
- */
-export async function applyPatches(patchesDir, engineDir) {
-    const patches = await discoverPatches(patchesDir);
-    const results = [];
-    const appliedFiles = new Set();
-    for (const patch of patches) {
-        const result = await applySinglePatch(patch, engineDir, appliedFiles);
-        results.push(result);
-        if (result.success) {
-            for (const file of extractAffectedFiles(await readText(patch.path))) {
-                appliedFiles.add(file);
-            }
-        }
-        // Stop on first failure and roll back all previously applied patches
-        if (!result.success) {
-            const succeeded = results.filter((r) => r.success);
-            if (succeeded.length > 0) {
-                verbose(`Rolling back ${succeeded.length} previously applied patch(es)…`);
-                await rollbackPatches(succeeded, engineDir);
-            }
-            break;
-        }
-    }
-    return results;
-}
-/**
- * Validates that all patches can be applied.
- * @param patchesDir - Path to the patches directory
- * @param engineDir - Path to the engine directory
- * @returns Validation results
- */
-export async function validatePatches(patchesDir, engineDir) {
-    const patches = await discoverPatches(patchesDir);
-    const errors = [];
-    for (const patch of patches) {
-        try {
-            const patchContent = await readText(patch.path);
-            await validatePatchTargets(patch, extractAffectedFiles(patchContent), engineDir);
-        }
-        catch (error) {
-            errors.push(`${patch.filename}: ${toError(error).message}`);
-            continue;
-        }
-        const result = await exec('git', ['apply', '--check', '--', patch.path], { cwd: engineDir });
-        if (result.exitCode !== 0) {
-            const message = result.stderr.trim() || 'git apply --check failed';
-            errors.push(`${patch.filename}: ${message}`);
-        }
-    }
-    return { valid: errors.length === 0, errors };
-}
 async function validatePatchTargets(patch, affectedFiles, engineDir) {
     // realpath the engine root once so containment is checked against the
     // physical tree (the root itself may sit behind a symlink, e.g. /tmp on
@@ -272,17 +215,14 @@ async function resolvePatchWriteDestination(targetPath) {
  *   1. **Exact filename** — `005-foo.patch`. Matches only that filename.
  *   2. **Filename without extension** — `005-foo`. Matches `005-foo.patch`.
  *   3. **Bare numeric ordinal** — `5` or `005`. Matches the patch whose
- *      order prefix parses to the same integer (so `5` and `005` both
- *      match `005-foo.patch`, and `05` matches too because parseInt
- *      normalizes leading zeros).
+ *      order prefix parses to the same integer (so `5` and `005` both match
+ *      `005-foo.patch`, and `05` matches too because parseInt normalizes
+ *      leading zeros).
  *
- * A purely-numeric identifier is treated **only** as an ordinal: it does
- * not also match a filename that happens to literally equal the digits.
- * That would require a patch literally named `5` or `005` — which would
- * collide with the filename prefix anyway — and we prefer the explicit
- * ordinal interpretation. The earlier form's `patchFilename === needle`
- * short-circuit was kept behind the numeric gate so the match stays
- * single-meaning per identifier.
+ * A purely-numeric identifier is treated **only** as an ordinal: it does not
+ * also match a filename that happens to literally equal the digits. That
+ * would require a patch literally named `5` or `005`, which would collide
+ * with the filename prefix anyway.
  */
 export function matchesUntilFilename(patchFilename, needle) {
     const isNumeric = /^\d+$/.test(needle);
@@ -395,11 +335,11 @@ export async function applyPatchesWithContinue(patchesDir, engineDir, optionsOrC
 }
 /**
  * Builds a batched patched-content context that loads the manifest and
- * discovers patch files ONCE for many lookups, and memoizes each patch
- * body read across the batch. The old per-call helper re-ran
- * `loadPatchesManifest` + `discoverPatches` and re-read every affecting
- * patch body for every file — O(dirtyFiles × patches) redundant IO when
- * classifying a broad engine edit session during `status` or `import`.
+ * discovers patch files ONCE for many lookups, and memoizes each patch body
+ * read across the batch. A per-call helper re-runs `loadPatchesManifest` +
+ * `discoverPatches` and re-reads every affecting patch body for every file —
+ * O(dirtyFiles × patches) redundant IO when classifying a broad engine edit
+ * session during `status` or `import`.
  */
 export async function createPatchedContentContext(patchesDir, engineDir) {
     const manifest = await loadPatchesManifest(patchesDir);