@hominis/fireforge 0.52.0 → 0.54.0

package/dist/src/core/config-validate.js

@@ -74,10 +74,10 @@ function parseFirefoxBlock(rec) {
         throw new ConfigError('Config field "firefox.version" must be a valid Firefox version (e.g., "145.0")');
     }
     const firefoxProduct = requireConfigString(firefoxRec, 'product', 'firefox.product');
-    // Uses the shared guard rather than a fourth copy of the member list. This
-    // is the fireforge.json read path: a product added to the union but not to
-    // the copy that used to live here would have been silently rejected from
-    // every project config.
+    // Uses the shared guard rather than a separate copy of the member list.
+    // This is the fireforge.json read path: a product added to the union but
+    // not to a local copy would be silently rejected from every project
+    // config.
     if (!isValidFirefoxProduct(firefoxProduct)) {
         throw new ConfigError(`Config field "firefox.product" must be one of: ${FIREFOX_PRODUCTS.join(', ')}`);
     }

package/dist/src/core/coverage-extend.d.ts

@@ -7,7 +7,7 @@
  * collapsing to this build's paths. `--extend-coverage` turns any drop into
  * a refusal before the build.
  *
- * Fingerprints must be complete: a legacy packageable-only record cannot
+ * Fingerprints must be complete: a record of packageable inputs only cannot
  * prove that a test fixture or manifest still matches its staged copy.
  */
 import type { BuildBaseline, CoverageAnchor, CoverageRecord, TestPackagingCoverage } from './build-baseline-types.js';
@@ -70,9 +70,11 @@ export interface RecordedCoverage {
  *
  * @param engineDir - Path to the engine directory
  * @param plan - Plan after {@link applyMozconfigAnchor}
- * @param requested - Normalized request paths this build packaged
+ * @param requestedPaths - Request paths this build packaged. Normalized
+ *   here (no trailing slash, no `./`): the baseline validator rejects the
+ *   raw CLI shapes, and a baseline it rejects refuses every later run.
  */
-export declare function recordScopedCoverage(engineDir: string, plan: CoverageRetentionPlan, requested: string[]): Promise<RecordedCoverage>;
+export declare function recordScopedCoverage(engineDir: string, plan: CoverageRetentionPlan, requestedPaths: string[]): Promise<RecordedCoverage>;
 /** Renders one dropped claim with its cause. */
 export declare function describeDroppedClaim(claim: DroppedClaim): string;
 /**

package/dist/src/core/coverage-extend.js

@@ -8,7 +8,7 @@
  * collapsing to this build's paths. `--extend-coverage` turns any drop into
  * a refusal before the build.
  *
- * Fingerprints must be complete: a legacy packageable-only record cannot
+ * Fingerprints must be complete: a record of packageable inputs only cannot
  * prove that a test fixture or manifest still matches its staged copy.
  */
 import { toError } from '../utils/errors.js';
@@ -163,11 +163,16 @@ export async function applyMozconfigAnchor(engineDir, plan) {
  *
  * @param engineDir - Path to the engine directory
  * @param plan - Plan after {@link applyMozconfigAnchor}
- * @param requested - Normalized request paths this build packaged
+ * @param requestedPaths - Request paths this build packaged. Normalized
+ *   here (no trailing slash, no `./`): the baseline validator rejects the
+ *   raw CLI shapes, and a baseline it rejects refuses every later run.
  */
-export async function recordScopedCoverage(engineDir, plan, requested) {
+export async function recordScopedCoverage(engineDir, plan, requestedPaths) {
     if (plan.keepFull)
         return { testPackagingCoverage: 'full' };
+    const requested = [
+        ...new Set(requestedPaths.map(normalizeRequestPath).filter((path) => path.length > 0)),
+    ];
     const records = { ...plan.retained };
     try {
         const state = await readEngineContentState(engineDir);

package/dist/src/core/coverage-records.d.ts

@@ -1,11 +1,10 @@
 /**
  * Per-path packaging-coverage anchors for scoped `fireforge test --build`.
  *
- * A scoped build used to carry one claim anchored to the whole engine, so
- * any edit outside the new scope (a peer's, on a shared engine, nearly
- * always) replaced it. Each staged request path now carries its own anchor
- * restricted to its own staging inputs, and a claim is dropped only when
- * one of those inputs changed.
+ * Each staged request path carries its own anchor restricted to its own
+ * staging inputs, and a claim is dropped only when one of those inputs
+ * changed. One claim anchored to the whole engine would be replaced by any
+ * edit outside the new scope (a peer's, on a shared engine, nearly always).
  *
  * The staging inputs of a request path are its manifest directory (the
  * nearest directory at or above it that holds a test manifest) plus every

package/dist/src/core/coverage-records.js

@@ -2,11 +2,10 @@
 /**
  * Per-path packaging-coverage anchors for scoped `fireforge test --build`.
  *
- * A scoped build used to carry one claim anchored to the whole engine, so
- * any edit outside the new scope (a peer's, on a shared engine, nearly
- * always) replaced it. Each staged request path now carries its own anchor
- * restricted to its own staging inputs, and a claim is dropped only when
- * one of those inputs changed.
+ * Each staged request path carries its own anchor restricted to its own
+ * staging inputs, and a claim is dropped only when one of those inputs
+ * changed. One claim anchored to the whole engine would be replaced by any
+ * edit outside the new scope (a peer's, on a shared engine, nearly always).
  *
  * The staging inputs of a request path are its manifest directory (the
  * nearest directory at or above it that holds a test manifest) plus every

package/dist/src/core/destructive.d.ts

@@ -128,8 +128,8 @@ export declare function confirmDestructive(input: DestructiveOpInput): Promise<D
 /**
  * Appends a single JSONL record to the project's patch history log
  * (`.fireforge/history.jsonl` unless `fireforge.json#history.path` says
- * otherwise; a log at the pre-0.50 `patches/.fireforge-history.jsonl` is
- * moved there first).
+ * otherwise; a log found at `patches/.fireforge-history.jsonl` is moved
+ * there first).
  *
  * Call order matters: append only after the mutation succeeds, never
  * pre-emptively, so rolled-back failures do not leave ghost entries. The log

package/dist/src/core/destructive.js

@@ -159,8 +159,8 @@ export async function confirmDestructive(input) {
 /**
  * Appends a single JSONL record to the project's patch history log
  * (`.fireforge/history.jsonl` unless `fireforge.json#history.path` says
- * otherwise; a log at the pre-0.50 `patches/.fireforge-history.jsonl` is
- * moved there first).
+ * otherwise; a log found at `patches/.fireforge-history.jsonl` is moved
+ * there first).
  *
  * Call order matters: append only after the mutation succeeds, never
  * pre-emptively, so rolled-back failures do not leave ghost entries. The log

package/dist/src/core/discard-baseline.d.ts

@@ -30,7 +30,7 @@ export interface DiscardBaselinePlan {
     /** Rename/copy only: baseline content for `originalPath` when that side is claimed. */
     expectedOriginalContent?: string | null;
 }
-/** Builds an all-unmanaged plan set, the `--to-upstream` (legacy) shape. */
+/** Builds an all-unmanaged plan set, the `--to-upstream` shape. */
 export declare function planUpstreamDiscards(entries: readonly GitStatusEntry[]): DiscardBaselinePlan[];
 /**
  * Plans the restore target for each status entry. Entries claimed by the
@@ -47,7 +47,7 @@ export declare function planDiscardBaselines(patchesDir: string, engineDir: stri
  * Applies one restore plan. Patch-claimed paths end up exactly as `import`
  * leaves them: patched content as an unstaged worktree state (tracked files
  * read ` M`, created files `??`), nothing staged. Unmanaged plans delegate
- * to the legacy {@link discardStatusEntry} mechanics.
+ * to the plain git {@link discardStatusEntry} mechanics.
  */
 export declare function applyDiscardBaseline(engineDir: string, plan: DiscardBaselinePlan): Promise<void>;
 /** One-line annotation for dry-run listings and confirmation summaries. */

package/dist/src/core/discard-baseline.js

@@ -24,7 +24,7 @@ import { createPatchedContentContext } from './patch-apply.js';
 import { loadPatchesManifestState } from './patch-manifest-io.js';
 import { parseDiffSections } from './patch-parse.js';
 import { buildPatchClaims } from './status-classify.js';
-/** Builds an all-unmanaged plan set, the `--to-upstream` (legacy) shape. */
+/** Builds an all-unmanaged plan set, the `--to-upstream` shape. */
 export function planUpstreamDiscards(entries) {
     return entries.map((entry) => ({ entry, kind: 'unmanaged', owners: [], conflicted: false }));
 }
@@ -151,7 +151,7 @@ export async function planDiscardBaselines(patchesDir, engineDir, entries) {
  * Applies one restore plan. Patch-claimed paths end up exactly as `import`
  * leaves them: patched content as an unstaged worktree state (tracked files
  * read ` M`, created files `??`), nothing staged. Unmanaged plans delegate
- * to the legacy {@link discardStatusEntry} mechanics.
+ * to the plain git {@link discardStatusEntry} mechanics.
  */
 export async function applyDiscardBaseline(engineDir, plan) {
     if (plan.kind === 'unmanaged') {
@@ -173,7 +173,7 @@ export async function applyDiscardBaseline(engineDir, plan) {
         await writeText(join(engineDir, entry.file), plan.expectedContent);
     }
     // A rename/copy's original side restores to its baseline too: the patch
-    // baseline when claimed, else the legacy HEAD restore (matching what
+    // baseline when claimed, else the HEAD restore (matching what
     // discardStatusEntry does for that side).
     if (entry.originalPath !== undefined) {
         if (plan.expectedOriginalContent !== undefined) {

package/dist/src/core/engine-session-lock.d.ts

@@ -77,7 +77,7 @@ export declare function generationDeltaPaths(before: string, after: string): {
 /**
  * Describes what moved between two generation tokens, in operator terms.
  *
- * The refusal used to say only that the engine changed, which left the
+ * A refusal that said only that the engine changed would leave the
  * operator to reconstruct the writer by hand: `find -newermt` against the
  * run window, minus the objdir, minus git's own bookkeeping. Everything
  * needed to answer it is already in the two tokens, so the refusal answers

package/dist/src/core/engine-session-lock.js

@@ -281,7 +281,7 @@ export function generationDeltaPaths(before, after) {
 /**
  * Describes what moved between two generation tokens, in operator terms.
  *
- * The refusal used to say only that the engine changed, which left the
+ * A refusal that said only that the engine changed would leave the
  * operator to reconstruct the writer by hand: `find -newermt` against the
  * run window, minus the objdir, minus git's own bookkeeping. Everything
  * needed to answer it is already in the two tokens, so the refusal answers

package/dist/src/core/file-lock-owner.d.ts

@@ -46,11 +46,11 @@ export declare function readLockOwner(lockPath: string): Promise<LockOwner>;
  * time, own start tick, diagnostic metadata) into a lock directory it has
  * just created, and reads the record back to prove it landed.
  *
- * The write is fatal. It used to be best-effort, on the theory that stale
- * recovery would fall back to the age heuristic, but that heuristic reaps
- * any owner-less lock after five minutes, and the build lock legitimately
- * holds for hours. A holder whose record failed to write was therefore
- * reaped mid-build and a second process entered the critical section. On
+ * The write is fatal rather than best-effort. Stale recovery could fall
+ * back to the age heuristic, but that heuristic reaps any owner-less lock
+ * after five minutes, and the build lock legitimately holds for hours. A
+ * holder whose record failed to write would be reaped mid-build and a
+ * second process would enter the critical section. On
  * failure the just-created lock directory is removed (nothing else can own
  * it yet) and a {@link GeneralError} names the cause.
  *

package/dist/src/core/file-lock-owner.js

@@ -141,11 +141,11 @@ async function readBackLockOwner(lockPath) {
  * time, own start tick, diagnostic metadata) into a lock directory it has
  * just created, and reads the record back to prove it landed.
  *
- * The write is fatal. It used to be best-effort, on the theory that stale
- * recovery would fall back to the age heuristic, but that heuristic reaps
- * any owner-less lock after five minutes, and the build lock legitimately
- * holds for hours. A holder whose record failed to write was therefore
- * reaped mid-build and a second process entered the critical section. On
+ * The write is fatal rather than best-effort. Stale recovery could fall
+ * back to the age heuristic, but that heuristic reaps any owner-less lock
+ * after five minutes, and the build lock legitimately holds for hours. A
+ * holder whose record failed to write would be reaped mid-build and a
+ * second process would enter the critical section. On
  * failure the just-created lock directory is removed (nothing else can own
  * it yet) and a {@link GeneralError} names the cause.
  *

package/dist/src/core/file-lock-queue.js

@@ -3,18 +3,16 @@
  * Waiter tickets for `withFileLock`: who is queued for a contended lock, in
  * what order, and whose turn it is.
  *
- * The queue started as a display: waiters advertised themselves so the wait
- * line could say "You are next", but the grant itself was a free-for-all of
- * `mkdir` polls. A waiter whose poll interval had backed off to 2 s lost
- * every free moment to later arrivals polling at 100 ms, so a run told it
- * was next for twenty minutes watched three later runs take the lock in
- * turn. The tickets now decide the grant: only the head of the queue may
- * attempt the lock, so the position printed is the position honoured.
+ * The tickets decide the grant: only the head of the queue may attempt the
+ * lock, so the position printed is the position honoured. A free-for-all of
+ * `mkdir` polls would let later arrivals polling at 100 ms take every free
+ * moment from a waiter whose poll interval had backed off to 2 s, so a run
+ * told it was next could watch later runs take the lock in turn.
  *
  * A ticket is a file in `<lock>.waiters/` named
  * `<startedAtMs>-<pid>-<uuid>`. Arrival order is the wait start, with the
  * whole name as a tie-break so every reader sorts the queue identically.
- * Because a ticket now blocks everyone behind it, a ticket whose owner is
+ * Because a ticket blocks everyone behind it, a ticket whose owner is
  * gone must not hold the queue: a dead PID (or a reused one, where the
  * start-tick check can tell) drops out and its ticket is removed, and a
  * ticket its owner has stopped refreshing drops out without being removed,

package/dist/src/core/file-lock-shared.d.ts

@@ -1,10 +1,10 @@
 /**
  * Shared holds on a FireForge directory lock.
  *
- * Every lock used to be exclusive, so two build-less `fireforge test` runs
- * on one objdir, each with its own profile and (under auto ports) its own
- * ports, still waited for each other: the gate's browser tiers ran strictly
- * serially on a 14-core host. A shared hold lets such runs overlap while
+ * Two build-less `fireforge test` runs on one objdir, each with its own
+ * profile and (under auto ports) its own ports, have no reason to wait for
+ * each other; with only exclusive holds the gate's browser tiers would run
+ * strictly serially on a many-core host. A shared hold lets such runs overlap while
  * anything that writes (a build, a re-export, a test run that builds)
  * still holds the lock alone.
  *

package/dist/src/core/file-lock-shared.js

@@ -2,10 +2,10 @@
 /**
  * Shared holds on a FireForge directory lock.
  *
- * Every lock used to be exclusive, so two build-less `fireforge test` runs
- * on one objdir, each with its own profile and (under auto ports) its own
- * ports, still waited for each other: the gate's browser tiers ran strictly
- * serially on a 14-core host. A shared hold lets such runs overlap while
+ * Two build-less `fireforge test` runs on one objdir, each with its own
+ * profile and (under auto ports) its own ports, have no reason to wait for
+ * each other; with only exclusive holds the gate's browser tiers would run
+ * strictly serially on a many-core host. A shared hold lets such runs overlap while
  * anything that writes (a build, a re-export, a test run that builds)
  * still holds the lock alone.
  *

package/dist/src/core/file-lock.js

@@ -269,10 +269,9 @@ async function buildLockTimeoutError(lockPath, onTimeoutMessage, cause, queue) {
  *
  * The queue is read at the moment the budget expires rather than taken from
  * the last progress probe. A probe snapshot is up to one `waitProgressMs`
- * stale, and, the reason this changed, it may not exist at all: a short
- * budget can expire before the first probe lands (a slow runner's
- * `registerWaiter` alone can outlast it), and a caller that configured no
- * probe at all never had one. Both used to lose the position silently.
+ * stale, and it may not exist at all: a short budget can expire before the
+ * first probe lands (a slow runner's `registerWaiter` alone can outlast it),
+ * and a caller that configured no probe at all never has one.
  */
 function formatQueuePositionReached(queue) {
     if (queue.depth === 0)
@@ -423,12 +422,10 @@ export async function withFileLock(lockPath, operation, options = {}) {
                 // buys a fresh budget, because the wait is working. Only a queue
                 // that stops moving starves, which is the case the timeout is for.
                 //
-                // The first observation is a seed, never an advance. `bestAhead`
-                // used to start `undefined`, so the opening probe always satisfied
-                // this test and handed out a free full budget: a `--wait-lock 300`
-                // run outlived its 300 s even against a queue that never moved
-                // once, which is the "it does not reliably give up after N
-                // seconds" behaviour a downstream fork reported.
+                // The first observation is a seed, never an advance. Counted as an
+                // advance, the opening probe would hand out a free full budget: a
+                // `--wait-lock 300` run would outlive its 300 s even against a queue
+                // that never moved once.
                 if (hardDeadline !== undefined) {
                     if (bestAhead === undefined) {
                         bestAhead = probe.queue.ahead;

package/dist/src/core/firefox.js

@@ -96,8 +96,8 @@ export async function downloadFirefoxSource(options) {
         await removeDir(tempDir);
         // Only throw away the ~600 MB cached archive when the failure indicts
         // the archive, not the environment. ENOSPC, a permission problem in
-        // destDir, or tar disappearing mid-run used to invalidate a perfectly
-        // good download and force a full re-fetch on retry.
+        // destDir, or tar disappearing mid-run leaves a perfectly good download
+        // that a retry can reuse without a full re-fetch.
         if (isLikelyArchiveCorruptionError(error)) {
             await invalidateArchiveCache(archive, cacheDir);
         }

package/dist/src/core/furnace-apply-overwrite-warn.d.ts

@@ -13,7 +13,7 @@
  * The per-file byte comparison already exists:
  * `checkRegistrationConsistency` for custom components (fragment- and
  * ftl-aware) and the copy-candidate walk for overrides. This module only
- * surfaces what was previously computed and thrown away.
+ * surfaces what those comparisons compute.
  */
 import type { CustomComponentConfig, OverrideComponentConfig } from '../types/furnace.js';
 /** One deployed, patch-owned file about to be overwritten with different bytes. */

package/dist/src/core/furnace-apply-overwrite-warn.js

@@ -14,7 +14,7 @@
  * The per-file byte comparison already exists:
  * `checkRegistrationConsistency` for custom components (fragment- and
  * ftl-aware) and the copy-candidate walk for overrides. This module only
- * surfaces what was previously computed and thrown away.
+ * surfaces what those comparisons compute.
  */
 import { readdir } from 'node:fs/promises';
 import { join, relative } from 'node:path';

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

@@ -258,9 +258,9 @@ async function applyCustomBatch(ctx, root, markerComment) {
                 filesAffectedTotal.push(...removed);
             }
             if (!dryRun) {
-                // Runs unconditionally. The `changed === true` path used to skip
-                // drift detection entirely, which is when a deployed engine-only
-                // fix gets silently replaced (J6).
+                // Runs unconditionally, including on the `changed === true` path:
+                // that is when a deployed engine-only fix gets silently replaced
+                // (J6).
                 recordOverwriteWarnings(result, await findPatchOwnedOverwrites({
                     type: 'custom',
                     root,

package/dist/src/core/furnace-operation.js

@@ -305,11 +305,11 @@ export async function completeJournalRollback(ctx, journal, error, options) {
 export async function forceReleaseFurnaceLocksForActiveOperations() {
     const paths = new Set([...activeOperations.values()].map((op) => getFurnaceLockPath(op.root)));
     for (const lockPath of paths) {
-        // Ownership-checked, like every other release path. The bare `rm` this
-        // replaced would delete a lock a different process had acquired in the
-        // window between our operation dying and this sweep running. That is the
-        // exact race `releaseLock`'s PID verification was added to close, reopened
-        // here because the sweeper has no acquisition token to check.
+        // Ownership-checked, like every other release path. A bare `rm` would
+        // delete a lock a different process had acquired in the window between
+        // our operation dying and this sweep running. That is the exact race
+        // `releaseLock`'s PID verification closes, and the sweeper has no
+        // acquisition token to check.
         const removed = await releaseLockIfOwned(lockPath);
         verbose(removed
             ? `Removed furnace lock at ${lockPath} during signal teardown`

package/dist/src/core/furnace-registration-jar-inplace.js

@@ -2,10 +2,9 @@
 /**
  * In-place edits to a widget's `toolkit/content/jar.mn` block.
  *
- * Undeploying one file and renaming a component used to drop every line of
- * the widget and re-add the live ones, which re-sorted the whole block and
- * left the owning patch carrying reorder hunks. These helpers touch only
- * the lines that change: a deleted file's line goes, a renamed component's
+ * Dropping every line of the widget and re-adding the live ones would
+ * re-sort the whole block and leave the owning patch carrying reorder
+ * hunks. These helpers touch only the lines that change: a deleted file's line goes, a renamed component's
  * lines are rewritten where they stand, and anything still missing is left
  * for `addJarMnEntries` to insert.
  */
@@ -15,8 +14,8 @@ import { escapeRegex } from '../utils/regex.js';
 import { JAR_MN } from './furnace-constants.js';
 /**
  * The file a widget jar.mn line registers: the `(widgets/<tag>/<file>)`
- * source mapping, or the legacy `content/global/elements/<tag>.<ext>`
- * target written before the mapping existed. Undefined when the line is
+ * source mapping, or the `content/global/elements/<tag>.<ext>` target of a
+ * line that carries no source mapping. Undefined when the line is
  * not one of this tag's.
  */
 function registeredFile(line, tagName) {

package/dist/src/core/furnace-registration-rename.d.ts

@@ -1,11 +1,11 @@
 /**
  * In-place rename of a custom element registration in customElements.js.
  *
- * `furnace rename` used to remove the old entry and add a new one. On a
- * registration list the remove path could not see, that left the old entry
- * beside the new one, and the new entry was written without the project
- * marker every sibling line carries (`// <MARKER>:`), so the next lint
- * flagged it as an unmarked engine edit. Rewriting the tag and module
+ * Removing the old entry and adding a new one would, on a registration
+ * list the remove path cannot see, leave the old entry beside the new one,
+ * and the new entry would lack the project marker every sibling line
+ * carries (`// <MARKER>:`), so the next lint would flag it as an unmarked
+ * engine edit. Rewriting the tag and module
  * literals inside the existing entry keeps the entry's position, layout and
  * trailing marker comments exactly as they were.
  */

package/dist/src/core/furnace-registration-rename.js

@@ -2,11 +2,11 @@
 /**
  * In-place rename of a custom element registration in customElements.js.
  *
- * `furnace rename` used to remove the old entry and add a new one. On a
- * registration list the remove path could not see, that left the old entry
- * beside the new one, and the new entry was written without the project
- * marker every sibling line carries (`// <MARKER>:`), so the next lint
- * flagged it as an unmarked engine edit. Rewriting the tag and module
+ * Removing the old entry and adding a new one would, on a registration
+ * list the remove path cannot see, leave the old entry beside the new one,
+ * and the new entry would lack the project marker every sibling line
+ * carries (`// <MARKER>:`), so the next lint would flag it as an unmarked
+ * engine edit. Rewriting the tag and module
  * literals inside the existing entry keeps the entry's position, layout and
  * trailing marker comments exactly as they were.
  */

package/dist/src/core/furnace-registration-validate.d.ts

@@ -1,6 +1,7 @@
 /**
  * Shared validation for furnace custom element registration placement.
- * Used after both AST and legacy code paths to avoid duplicating logic.
+ * Shared by the AST registration editor and the registration validator to
+ * avoid duplicating logic.
  */
 /**
  * Regex for valid custom element tag names. A valid name is lowercase, starts

package/dist/src/core/furnace-registration-validate.js

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
  * Shared validation for furnace custom element registration placement.
- * Used after both AST and legacy code paths to avoid duplicating logic.
+ * Shared by the AST registration editor and the registration validator to
+ * avoid duplicating logic.
  */
 import { FurnaceError } from '../errors/furnace.js';
 import { escapeRegex, stripJsComments } from '../utils/regex.js';

package/dist/src/core/furnace-registration.js

@@ -252,8 +252,8 @@ export async function removeJarMnEntries(engineDir, tagName) {
     // line the component registered is removed regardless of the target
     // basename. A helper `.mjs` whose name does not start with the tag (e.g.
     // a renamed `foo-utils.mjs`) otherwise survives the remove pass and leaves
-    // a stale registration that breaks packaging. The legacy target-path match
-    // is kept as an OR for lines written before the source mapping existed.
+    // a stale registration that breaks packaging. The target-path match is
+    // kept as an OR for lines that carry no source mapping.
     // Word boundaries keep "moz-card" from matching "moz-card-group".
     const sourcePattern = new RegExp(`\\(widgets/${escapeRegex(tagName)}/`);
     const legacyTargetPattern = new RegExp(`content/global/elements/${escapeRegex(tagName)}\\.`);

package/dist/src/core/git-base.js

@@ -45,9 +45,10 @@ export const GIT_ADD_CHUNK_TIMEOUT_MS = resolveTimeoutFromEnv(GIT_ADD_CHUNK_TIME
 /**
  * In-flight or settled successful `git` availability probe.
  *
- * The probe spawns `which git` (or `where` on Windows), and every git wrapper
- * in this layer used to run it before each command, which meant dozens of
- * extra spawns per `fireforge export`. Only success is cached: a rejection
+ * The probe spawns `which git` (or `where` on Windows); running it before
+ * every command would mean dozens of extra spawns per `fireforge export`, so
+ * the result is shared by every git wrapper in this layer. Only success is
+ * cached: a rejection
  * clears the slot so a run that installs git mid-flight (or a test that flips
  * the probe) sees the new answer instead of a sticky refusal.
  */

package/dist/src/core/git-diff.js

@@ -521,7 +521,7 @@ async function generateBinaryFilePatchWithConfig(repoDir, filePath, gitConfigArg
  * "absent", and this branch only runs for files untracked in HEAD). A prior
  * stage-0 entry is re-pointed at its recorded mode and blob. Unmerged entries
  * (stages 1 to 3) cannot be rebuilt through `--cacheinfo`. That degenerate
- * state keeps the legacy reset-to-HEAD behavior rather than corrupting the
+ * state falls back to the reset-to-HEAD restore rather than corrupting the
  * conflict.
  * @param repoDir - Repository directory
  * @param filePath - File path (relative to repo root)

package/dist/src/core/git.js

@@ -46,7 +46,7 @@ const GIT_ADD_ENV = { GIT_INDEX_THREADS: '0' };
  * AbortError when the signal fires, so both shapes have to be recognised.
  */
 function isTimeoutError(error) {
-    // `exec` now rejects with a typed ExecTimeoutError when its `timeout`
+    // `exec` rejects with a typed ExecTimeoutError when its `timeout`
     // option fires (the raw AbortError check below is kept for defence in
     // depth against other abort paths).
     if (error instanceof ExecTimeoutError)

package/dist/src/core/harness-orphans.d.ts

@@ -45,12 +45,12 @@ export interface OrphanedHarnessProcess {
  * True when `command` IS a harness helper: its executable is a helper
  * binary, or an interpreter whose first argument is a helper script.
  *
- * Structural on purpose. An earlier version matched the helper names
- * anywhere in the command line, which is right for the httpd (`xpcshell -g
- * … -f …/server.js`) and wrong for everything that merely mentions such a
- * path: an editor opened on `server.js`, a shell whose command text quotes
- * it, a `grep` over the objdir. Report-only, that printed a misleading
- * `kill`; under the reap posture it terminated the operator's shell.
+ * Structural on purpose. Matching the helper names anywhere in the command
+ * line is right for the httpd (`xpcshell -g … -f …/server.js`) and wrong for
+ * everything that merely mentions such a path: an editor opened on
+ * `server.js`, a shell whose command text quotes it, a `grep` over the
+ * objdir. Report-only, that would print a misleading `kill`; under the reap
+ * posture it would terminate the operator's shell.
  */
 export declare function matchesHarnessHelper(command: string): boolean;
 /** Objdir provenance: an explicit objdir path, a `obj-…` path segment, or `_tests/`. */

package/dist/src/core/harness-orphans.js

@@ -55,12 +55,12 @@ function basename(token) {
  * True when `command` IS a harness helper: its executable is a helper
  * binary, or an interpreter whose first argument is a helper script.
  *
- * Structural on purpose. An earlier version matched the helper names
- * anywhere in the command line, which is right for the httpd (`xpcshell -g
- * … -f …/server.js`) and wrong for everything that merely mentions such a
- * path: an editor opened on `server.js`, a shell whose command text quotes
- * it, a `grep` over the objdir. Report-only, that printed a misleading
- * `kill`; under the reap posture it terminated the operator's shell.
+ * Structural on purpose. Matching the helper names anywhere in the command
+ * line is right for the httpd (`xpcshell -g … -f …/server.js`) and wrong for
+ * everything that merely mentions such a path: an editor opened on
+ * `server.js`, a shell whose command text quotes it, a `grep` over the
+ * objdir. Report-only, that would print a misleading `kill`; under the reap
+ * posture it would terminate the operator's shell.
  */
 export function matchesHarnessHelper(command) {
     const [exe, first] = command.trim().split(/\s+/);