@hominis/fireforge 0.43.1 → 0.44.0

package/dist/src/core/wire-destroy.d.ts

@@ -5,9 +5,9 @@
  * AST-based implementation: finds onUnload()/uninit() method body and
  * inserts the destroy block at the top (LIFO ordering).
  *
- * `marker` is prefixed to the generated comment so wire-generated
- * edits carry the patch-lint `// <MARKER>:` signature
- * `lintModificationComments` looks for (eval 1 Finding #9).
+ * `marker` is prefixed to the generated comment so wire-generated edits
+ * carry the patch-lint `// <MARKER>:` signature `lintModificationComments`
+ * looks for.
  */
 export declare function addDestroyAST(content: string, expression: string, marker?: string): string;
 /**

package/dist/src/core/wire-destroy.js

@@ -9,7 +9,7 @@ import { BuildError } from '../errors/build.js';
 import { pathExists, readText, writeText } from '../utils/fs.js';
 import { escapeRegex } from '../utils/regex.js';
 import { asEstree, detectIndent, parseScript } from './ast-utils.js';
-import { withParserFallback } from './parser-fallback.js';
+import { isInternalInvariantFailure, withParserFallback } from './parser-fallback.js';
 import { assertBraceBalancePreserved, coerceToCall, extractNameFromExpression, findMethodBody, findMethodBraceIndex, validateWireName, } from './wire-utils.js';
 const BROWSER_INIT_JS = 'browser/base/content/browser-init.js';
 const DEFAULT_MARKER = 'FIREFORGE:';
@@ -17,9 +17,9 @@ const DEFAULT_MARKER = 'FIREFORGE:';
  * AST-based implementation: finds onUnload()/uninit() method body and
  * inserts the destroy block at the top (LIFO ordering).
  *
- * `marker` is prefixed to the generated comment so wire-generated
- * edits carry the patch-lint `// <MARKER>:` signature
- * `lintModificationComments` looks for (eval 1 Finding #9).
+ * `marker` is prefixed to the generated comment so wire-generated edits
+ * carry the patch-lint `// <MARKER>:` signature `lintModificationComments`
+ * looks for.
  */
 export function addDestroyAST(content, expression, marker = DEFAULT_MARKER) {
     const name = extractNameFromExpression(expression);
@@ -110,22 +110,14 @@ export async function addDestroyToBrowserInit(engineDir, expression, marker = DE
     const content = await readText(filePath);
     // Idempotency check — look for the coerced (call) form because that is
     // what the emitter writes. Matching against the raw input would miss a
-    // previous `EvalStartup.destroy` invocation that the 0.16.0 coercion
-    // already persisted as `EvalStartup.destroy()`.
+    // bare `X.destroy` invocation that coercion already persisted as
+    // `X.destroy()`.
     const callExpression = coerceToCall(expression);
     const destroyPattern = new RegExp(`(?:^|\\W)${escapeRegex(callExpression)}\\s*;?\\s*$`, 'm');
     if (destroyPattern.test(content)) {
         return false;
     }
-    const { value, usedFallback } = withParserFallback(() => addDestroyAST(content, expression, marker), () => legacyAddDestroy(content, expression, marker), BROWSER_INIT_JS, 
-    // Rethrow only the internal-invariant GeneralErrors ("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.
-    (error) => error instanceof GeneralError);
+    const { value, usedFallback } = withParserFallback(() => addDestroyAST(content, expression, marker), () => legacyAddDestroy(content, expression, marker), BROWSER_INIT_JS, isInternalInvariantFailure);
     if (usedFallback) {
         assertBraceBalancePreserved(content, value, BROWSER_INIT_JS);
     }

package/dist/src/core/wire-dom-fragment.d.ts

@@ -13,24 +13,16 @@ export declare const DEFAULT_DOM_TARGET = "browser/base/content/browser.xhtml";
  */
 export declare function addDomFragmentTokenized(content: string, includeDirective: string): string;
 /**
- * Legacy line-based implementation preserved as fallback.
- */
-export declare function legacyAddDomFragment(content: string, includeDirective: string): string;
-/**
- * Dry-run precheck for `addDomFragment`. Reads the resolved chrome
- * document and verifies it either already contains the `#include`
- * directive (the idempotent-skip case) OR offers a locatable insertion
- * point via {@link addDomFragmentTokenized} / {@link legacyAddDomFragment}.
- * Throws the same `Could not find insertion point in chrome document`
- * error the real run would throw when neither condition holds.
+ * Dry-run precheck for `addDomFragment`. Reads the resolved chrome document
+ * and verifies it either already contains the `#include` directive (the
+ * idempotent-skip case) OR offers a locatable insertion point via
+ * {@link addDomFragmentTokenized} / {@link legacyAddDomFragment}. Throws the
+ * same `Could not find insertion point in chrome document` error the real
+ * run would throw when neither condition holds.
  *
- * Motivating case (2026-04-21 eval, Finding #12): `fireforge wire ...
- * --dry-run` previewed a plausible mutation plan against
- * `tokenHostDocuments[0]`, then `fireforge wire ...` without
- * `--dry-run` threw `Could not find insertion point in chrome document`
- * on the same arguments. The real run had always called the insertion
- * helpers; dry-run did not. This helper runs the same check in the
- * preview pass so plan and execution disagree less.
+ * Without it, `wire --dry-run` previews a plausible mutation plan while the
+ * real run throws on the same arguments, because only the real run called
+ * the insertion helpers.
  */
 export declare function probeDomFragmentInsertionPoint(engineDir: string, domFilePath: string, targetPath?: string): Promise<void>;
 /**

package/dist/src/core/wire-dom-fragment.js

@@ -13,7 +13,6 @@ import { GeneralError } from '../errors/base.js';
 import { pathExists, readText, writeText } from '../utils/fs.js';
 import { toRootRelativePath } from '../utils/paths.js';
 import { escapeRegex } from '../utils/regex.js';
-import { withParserFallback } from './parser-fallback.js';
 import { tokenizeXhtml } from './wire-utils.js';
 export const DEFAULT_DOM_TARGET = 'browser/base/content/browser.xhtml';
 /**
@@ -48,48 +47,16 @@ export function addDomFragmentTokenized(content, includeDirective) {
     return lines.join('\n');
 }
 /**
- * Legacy line-based implementation preserved as fallback.
- */
-export function legacyAddDomFragment(content, includeDirective) {
-    const lines = content.split('\n');
-    let insertIndex = -1;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i] ?? '';
-        if (/browser-sets\.inc/.test(line)) {
-            insertIndex = i;
-            break;
-        }
-    }
-    if (insertIndex === -1) {
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i] ?? '';
-            if (/<html:body/.test(line)) {
-                insertIndex = i + 1;
-                break;
-            }
-        }
-    }
-    if (insertIndex === -1) {
-        throw new GeneralError('Could not find insertion point in chrome document');
-    }
-    lines.splice(insertIndex, 0, includeDirective);
-    return lines.join('\n');
-}
-/**
- * Dry-run precheck for `addDomFragment`. Reads the resolved chrome
- * document and verifies it either already contains the `#include`
- * directive (the idempotent-skip case) OR offers a locatable insertion
- * point via {@link addDomFragmentTokenized} / {@link legacyAddDomFragment}.
- * Throws the same `Could not find insertion point in chrome document`
- * error the real run would throw when neither condition holds.
+ * Dry-run precheck for `addDomFragment`. Reads the resolved chrome document
+ * and verifies it either already contains the `#include` directive (the
+ * idempotent-skip case) OR offers a locatable insertion point via
+ * {@link addDomFragmentTokenized} / {@link legacyAddDomFragment}. Throws the
+ * same `Could not find insertion point in chrome document` error the real
+ * run would throw when neither condition holds.
  *
- * Motivating case (2026-04-21 eval, Finding #12): `fireforge wire ...
- * --dry-run` previewed a plausible mutation plan against
- * `tokenHostDocuments[0]`, then `fireforge wire ...` without
- * `--dry-run` threw `Could not find insertion point in chrome document`
- * on the same arguments. The real run had always called the insertion
- * helpers; dry-run did not. This helper runs the same check in the
- * preview pass so plan and execution disagree less.
+ * Without it, `wire --dry-run` previews a plausible mutation plan while the
+ * real run throws on the same arguments, because only the real run called
+ * the insertion helpers.
  */
 export async function probeDomFragmentInsertionPoint(engineDir, domFilePath, targetPath = DEFAULT_DOM_TARGET) {
     const targetAbsPath = join(engineDir, targetPath);
@@ -113,7 +80,7 @@ export async function probeDomFragmentInsertionPoint(engineDir, domFilePath, tar
     // Check the tokenised and legacy insertion paths symmetrically with
     // the real run. Either helper returning without throwing is sufficient
     // evidence that the real run can land the directive.
-    withParserFallback(() => addDomFragmentTokenized(content, includeDirective), () => legacyAddDomFragment(content, includeDirective), targetPath);
+    addDomFragmentTokenized(content, includeDirective);
 }
 /**
  * Inserts a `#include` directive for an `.inc.xhtml` file into the top-level
@@ -177,7 +144,7 @@ export async function addDomFragment(engineDir, domFilePath, targetPath = DEFAUL
         }
     }
     // Normal insertion
-    const { value } = withParserFallback(() => addDomFragmentTokenized(content, includeDirective), () => legacyAddDomFragment(content, includeDirective), targetPath);
+    const value = addDomFragmentTokenized(content, includeDirective);
     await writeText(targetAbsPath, value);
     return true;
 }

package/dist/src/core/wire-init.d.ts

@@ -8,9 +8,8 @@
  *
  * `marker` is prepended (uppercased) to the generated comment line so the
  * emitted block carries the patch-lint `// <MARKER>:` signature that
- * `lintModificationComments` looks for. Otherwise the first export after
- * `wire` trips `missing-modification-comment` on wire-generated edits —
- * exactly the eval 1 Finding #9 regression.
+ * `lintModificationComments` looks for; otherwise the first export after
+ * `wire` trips `missing-modification-comment` on wire-generated edits.
  */
 export declare function addInitAST(content: string, expression: string, after?: string, marker?: string): string;
 /**

package/dist/src/core/wire-init.js

@@ -9,7 +9,7 @@ import { BuildError } from '../errors/build.js';
 import { pathExists, readText, writeText } from '../utils/fs.js';
 import { escapeRegex } from '../utils/regex.js';
 import { asEstree, detectIndent, getNodeSource, parseScript, } from './ast-utils.js';
-import { withParserFallback } from './parser-fallback.js';
+import { isInternalInvariantFailure, withParserFallback } from './parser-fallback.js';
 import { assertBraceBalancePreserved, coerceToCall, extractNameFromExpression, findInsertionAfterFireforgeBlocks, findMethodBody, findMethodBraceIndex, validateWireName, walkToTryBlockEnd, } from './wire-utils.js';
 const BROWSER_INIT_JS = 'browser/base/content/browser-init.js';
 /**
@@ -23,10 +23,9 @@ const DEFAULT_MARKER = 'FIREFORGE:';
  * the top of the method body when there is none.
  *
  * Both callers below — the `--after`-target-not-found fallthrough and the
- * no-`--after` default — ran a character-for-character copy of this ladder,
- * including both throw guards. `browser-init.js` is written through those two
- * independent paths and they MUST emit identical blocks, so having one
- * implementation enforces the invariant rather than merely tidying.
+ * no-`--after` default — must emit identical blocks, since `browser-init.js`
+ * is written through both paths. One implementation enforces that invariant
+ * rather than merely tidying.
  */
 function resolveDefaultInsertion(content, body, fireforgeBlocks) {
     if (fireforgeBlocks.length > 0) {
@@ -49,9 +48,8 @@ function resolveDefaultInsertion(content, body, fireforgeBlocks) {
  *
  * `marker` is prepended (uppercased) to the generated comment line so the
  * emitted block carries the patch-lint `// <MARKER>:` signature that
- * `lintModificationComments` looks for. Otherwise the first export after
- * `wire` trips `missing-modification-comment` on wire-generated edits —
- * exactly the eval 1 Finding #9 regression.
+ * `lintModificationComments` looks for; otherwise the first export after
+ * `wire` trips `missing-modification-comment` on wire-generated edits.
  */
 export function addInitAST(content, expression, after, marker = DEFAULT_MARKER) {
     const name = extractNameFromExpression(expression);
@@ -206,22 +204,13 @@ export async function addInitToBrowserInit(engineDir, expression, after, marker
     const content = await readText(filePath);
     // Idempotency check — look for the coerced (call) form because that is
     // what the emitter writes. Matching against the raw input would miss a
-    // previous `EvalStartup.init` invocation that the 0.16.0 coercion
-    // already persisted as `EvalStartup.init()`.
+    // bare `X.init` invocation that coercion already persisted as `X.init()`.
     const callExpression = coerceToCall(expression);
     const initPattern = new RegExp(`(?:^|\\W)${escapeRegex(callExpression)}\\s*;?\\s*$`, 'm');
     if (initPattern.test(content)) {
         return false;
     }
-    const { value, usedFallback } = withParserFallback(() => addInitAST(content, expression, after, marker), () => legacyAddInit(content, expression, after, marker), BROWSER_INIT_JS, 
-    // Rethrow only the internal-invariant GeneralErrors ("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.
-    (error) => error instanceof GeneralError);
+    const { value, usedFallback } = withParserFallback(() => addInitAST(content, expression, after, marker), () => legacyAddInit(content, expression, after, marker), BROWSER_INIT_JS, isInternalInvariantFailure);
     if (usedFallback) {
         assertBraceBalancePreserved(content, value, BROWSER_INIT_JS);
     }

package/dist/src/core/wire-subscript.d.ts

@@ -5,9 +5,8 @@
  * AST-based implementation: finds the last try/catch containing
  * `loadSubScript` and inserts a new try/catch block after it.
  *
- * The inserted block carries a `// <MARKER>: wire-subscript ...` comment
- * so the emitted edit satisfies `lintModificationComments` (eval 1
- * Finding #9).
+ * The inserted block carries a `// <MARKER>: wire-subscript ...` comment so
+ * the emitted edit satisfies `lintModificationComments`.
  */
 export declare function addSubscriptAST(content: string, name: string, marker?: string): string;
 /**

package/dist/src/core/wire-subscript.js

@@ -8,7 +8,7 @@ import { GeneralError } from '../errors/base.js';
 import { BuildError } from '../errors/build.js';
 import { pathExists, readText, writeText } from '../utils/fs.js';
 import { asEstree, detectIndent, getNodeSource, parseScript, walkAST, } from './ast-utils.js';
-import { withParserFallback } from './parser-fallback.js';
+import { isInternalInvariantFailure, withParserFallback } from './parser-fallback.js';
 import { assertBraceBalancePreserved, findNearestTryLine, validateWireName, walkToTryBlockEnd, } from './wire-utils.js';
 const BROWSER_MAIN_JS = 'browser/base/content/browser-main.js';
 const DEFAULT_MARKER = 'FIREFORGE:';
@@ -16,9 +16,8 @@ const DEFAULT_MARKER = 'FIREFORGE:';
  * AST-based implementation: finds the last try/catch containing
  * `loadSubScript` and inserts a new try/catch block after it.
  *
- * The inserted block carries a `// <MARKER>: wire-subscript ...` comment
- * so the emitted edit satisfies `lintModificationComments` (eval 1
- * Finding #9).
+ * The inserted block carries a `// <MARKER>: wire-subscript ...` comment so
+ * the emitted edit satisfies `lintModificationComments`.
  */
 export function addSubscriptAST(content, name, marker = DEFAULT_MARKER) {
     const ast = parseScript(content);
@@ -137,15 +136,7 @@ export async function addSubscriptToBrowserMain(engineDir, name, marker = DEFAUL
     if (content.includes(`content/${name}.js"`)) {
         return false;
     }
-    const { value, usedFallback } = withParserFallback(() => addSubscriptAST(content, name, marker), () => legacyAddSubscript(content, name, marker), BROWSER_MAIN_JS, 
-    // Rethrow only the internal-invariant GeneralErrors ("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.
-    (error) => error instanceof GeneralError);
+    const { value, usedFallback } = withParserFallback(() => addSubscriptAST(content, name, marker), () => legacyAddSubscript(content, name, marker), BROWSER_MAIN_JS, isInternalInvariantFailure);
     if (usedFallback) {
         assertBraceBalancePreserved(content, value, BROWSER_MAIN_JS);
     }

package/dist/src/core/wire-utils.d.ts

@@ -9,15 +9,14 @@ export declare function validateWireName(value: string, label: string): void;
  * Coerces an init/destroy expression into a function call by appending `()`
  * when the caller passed a bare property chain. Idempotent: an expression
  * already ending in `()` is returned unchanged, so operators can pass either
- * `EvalStartup.init` or `EvalStartup.init()` and get the same wired output.
+ * `Startup.init` or `Startup.init()` and get the same wired output.
  *
- * Motivation (eval finding 8): `validateWireName` accepts both shapes, but
- * the generated block interpolated the expression verbatim inside
- * `${expression};`. When a caller passed `EvalStartup.init`, the emitted
- * code was `EvalStartup.init;` — a plain property reference that never
- * invoked the lifecycle hook. The symptom was silent: `wire` reported
- * success and the browser-init block looked plausible, but the hook
- * never fired at runtime. Coercion at the template site closes that gap.
+ * `validateWireName` accepts both shapes, but the generated block
+ * interpolates the expression verbatim inside `${expression};` — so a bare
+ * `Startup.init` emits `Startup.init;`, a plain property reference that
+ * never invokes the lifecycle hook. The symptom is silent: `wire` reports
+ * success and the browser-init block looks plausible, but the hook never
+ * fires at runtime.
  */
 export declare function coerceToCall(expression: string): string;
 /**

package/dist/src/core/wire-utils.js

@@ -21,15 +21,14 @@ export function validateWireName(value, label) {
  * Coerces an init/destroy expression into a function call by appending `()`
  * when the caller passed a bare property chain. Idempotent: an expression
  * already ending in `()` is returned unchanged, so operators can pass either
- * `EvalStartup.init` or `EvalStartup.init()` and get the same wired output.
+ * `Startup.init` or `Startup.init()` and get the same wired output.
  *
- * Motivation (eval finding 8): `validateWireName` accepts both shapes, but
- * the generated block interpolated the expression verbatim inside
- * `${expression};`. When a caller passed `EvalStartup.init`, the emitted
- * code was `EvalStartup.init;` — a plain property reference that never
- * invoked the lifecycle hook. The symptom was silent: `wire` reported
- * success and the browser-init block looked plausible, but the hook
- * never fired at runtime. Coercion at the template site closes that gap.
+ * `validateWireName` accepts both shapes, but the generated block
+ * interpolates the expression verbatim inside `${expression};` — so a bare
+ * `Startup.init` emits `Startup.init;`, a plain property reference that
+ * never invokes the lifecycle hook. The symptom is silent: `wire` reports
+ * success and the browser-init block looks plausible, but the hook never
+ * fires at runtime.
  */
 export function coerceToCall(expression) {
     return expression.endsWith('()') ? expression : `${expression}()`;

package/dist/src/core/xpcshell-appdir.d.ts

@@ -8,33 +8,32 @@
  * The upstream xpcshell harness computes the manifest key for the appdir
  * override as `mozInfo["appname"] + "-appdir"`. On a stock Firefox build the
  * key is `firefox-appdir`, so the very common `firefox-appdir = "browser"`
- * directive is honoured. On a rebranded fork (appname=`mybrowser`, …) the
- * harness looks for `mybrowser-appdir`
- * — the literal `firefox-appdir` line is silently ignored, `appPath` falls
- * back to `xrePath`, and every `resource:///modules/…` import throws
- * `Failed to load resource:///modules/<name>.sys.mjs` because xpcshell now
- * resolves the `resource:///` prefix one level above the real app root.
+ * directive is honoured. On a rebranded fork (appname=`mybrowser`) the
+ * harness looks for `mybrowser-appdir` — the literal `firefox-appdir` line
+ * is silently ignored, `appPath` falls back to `xrePath`, and every
+ * `resource:///modules/…` import throws `Failed to load
+ * resource:///modules/<name>.sys.mjs` because xpcshell resolves the
+ * `resource:///` prefix one level above the real app root.
  *
  * ## Strategy
  *
  * 1. For each test path the operator handed us, find the nearest
  *    `xpcshell.toml`. If none exists, the test is not an xpcshell test and
- *    nothing to inject.
+ *    there is nothing to inject.
  * 2. Read the manifest's `[DEFAULT]` section. Look for `<appname>-appdir`
- *    first — if present, the harness already finds it and there's nothing to
- *    do. Fall back to `firefox-appdir`. This ordering matches upstream
- *    precedence and avoids overriding an operator who already migrated.
+ *    first — if present, the harness already finds it. Fall back to
+ *    `firefox-appdir`. This ordering matches upstream precedence and avoids
+ *    overriding an operator who already migrated.
  * 3. If only `firefox-appdir` is present and `appname != "firefox"`, compute
- *    the absolute app dir path against the active `obj-X/dist` tree
- *    (probing `dist/bin/<value>` first, then any `dist/<bundle>.app/Contents/
- *    Resources/<value>` for the macOS packaged layout) and return it as
- *    the value to pass to `--app-path`.
- * 4. If multiple test paths disagree on the resolved value (e.g. one
- *    manifest sets `browser`, another sets `xulrunner`), refuse injection
+ *    the absolute app dir path against the active `obj-X/dist` tree (probing
+ *    `dist/bin/<value>` first, then any
+ *    `dist/<bundle>.app/Contents/Resources/<value>` for the macOS packaged
+ *    layout) and return it as the value to pass to `--app-path`.
+ * 4. If multiple test paths disagree on the resolved value, refuse injection
  *    and return null — the operator can drop down to `--mach-arg`.
  *
- * Operator escape hatches: `--mach-arg=--app-path=…` always wins (handled in
- * test.ts; we skip injection when `--app-path=` already appears in the
+ * Operator escape hatch: `--mach-arg=--app-path=…` always wins (handled in
+ * test.ts, which skips injection when `--app-path=` already appears in the
  * forwarded args).
  */
 /**
@@ -75,15 +74,14 @@ export declare function parseAppdirFromToml(tomlText: string, key: string): {
  * returns the absolute path of the first sibling `xpcshell.toml` found.
  * Stops at `engineDir` (inclusive) and returns null on miss.
  *
- * Special-cases `startPath` itself when it already ends with
- * `xpcshell.toml` — operators sometimes pass a manifest path directly.
+ * Special-cases `startPath` itself when it already ends with `xpcshell.toml`
+ * — operators sometimes pass a manifest path directly.
  *
  * When `startPath` is a DIRECTORY, the walk starts at the directory itself
- * (checking `<dir>/xpcshell.toml` first) rather than at its parent. Field
- * report (0.34.0 cycle): a directory whose own manifest is an
- * `xpcshell.toml` was classified non-xpcshell — the walk began at the
- * parent, missed the manifest, and `fireforge test <dir>` dispatched to
- * the mochitest runner, which found no mochitests.
+ * (checking `<dir>/xpcshell.toml` first) rather than at its parent.
+ * Starting at the parent misses a directory's own manifest, so
+ * `fireforge test <dir>` classifies it non-xpcshell and dispatches to the
+ * mochitest runner, which finds no mochitests.
  */
 export declare function findNearestXpcshellManifest(engineDir: string, startPath: string): Promise<string | null>;
 /**
@@ -96,32 +94,27 @@ export declare function findNearestXpcshellManifest(engineDir: string, startPath
  */
 export declare function readMozinfoAppname(objDirPath: string): Promise<string>;
 /**
- * Probes the obj-dir's `dist/` subtree for the absolute path that the
- * harness would have computed if the manifest key had been honoured.
- * Returns null when no candidate exists — better to skip injection
- * silently than to point the harness at a path that doesn't exist
- * (which fails with a different error than the original `firefox-appdir`
- * symptom and confuses triage).
+ * Probes the obj-dir's `dist/` subtree for the absolute path the harness
+ * would have computed if the manifest key had been honoured. Returns null
+ * when no candidate exists — better to skip injection silently than to point
+ * the harness at a path that does not exist, which fails with a different
+ * error than the original symptom and confuses triage.
  *
  * Probe order differs by host platform:
  *
- * - **macOS (`darwin`)**: prefer `<objDir>/dist/<App>.app/Contents/Resources/
- *   <value>` FIRST, then fall back to `<objDir>/dist/bin/<value>`.
- *   2026-04-24 eval Finding 8: on macOS `dist/bin` is symlinked to
+ * - **macOS (`darwin`)**: prefer
+ *   `<objDir>/dist/<App>.app/Contents/Resources/<value>` FIRST, then fall
+ *   back to `<objDir>/dist/bin/<value>`. On macOS `dist/bin` is symlinked to
  *   `dist/<App>.app/Contents/MacOS/` (the *binaries* directory), so
- *   `dist/bin/browser` actually resolves to `<App>.app/Contents/MacOS/
- *   browser/`. That is NOT where `resource:///modules/` is rooted — on
- *   macOS, `-a` for xpcshell must point at the `.app/Contents/Resources/
- *   <value>` subtree where modules / chrome.manifest live. Returning
- *   `dist/bin/browser` caused the injected `--app-path` to look
- *   successful (the info log showed it) but pointed at a directory
- *   without the modules tree, so every `resource:///modules/…` import
- *   still threw.
- * - **non-macOS**: keep the historical order — `dist/bin/<value>` first,
+ *   `dist/bin/browser` resolves to `<App>.app/Contents/MacOS/browser/` —
+ *   NOT where `resource:///modules/` is rooted. Injecting that path looks
+ *   successful in the log but points at a directory with no modules tree, so
+ *   every `resource:///modules/…` import still throws.
+ * - **non-macOS**: `dist/bin/<value>` first,
  *   `.app/Contents/Resources/<value>` as fallback.
  *
- * On both platforms the final `.app` fallback iterates every `*.app`
- * entry because a rebranded fork may pick an arbitrary app name.
+ * On both platforms the final `.app` fallback iterates every `*.app` entry
+ * because a rebranded fork may pick an arbitrary app name.
  */
 export declare function resolveAbsoluteAppPath(objDirAbs: string, relativeAppdir: string): Promise<string | null>;
 /**

package/dist/src/core/xpcshell-appdir.js

@@ -9,33 +9,32 @@
  * The upstream xpcshell harness computes the manifest key for the appdir
  * override as `mozInfo["appname"] + "-appdir"`. On a stock Firefox build the
  * key is `firefox-appdir`, so the very common `firefox-appdir = "browser"`
- * directive is honoured. On a rebranded fork (appname=`mybrowser`, …) the
- * harness looks for `mybrowser-appdir`
- * — the literal `firefox-appdir` line is silently ignored, `appPath` falls
- * back to `xrePath`, and every `resource:///modules/…` import throws
- * `Failed to load resource:///modules/<name>.sys.mjs` because xpcshell now
- * resolves the `resource:///` prefix one level above the real app root.
+ * directive is honoured. On a rebranded fork (appname=`mybrowser`) the
+ * harness looks for `mybrowser-appdir` — the literal `firefox-appdir` line
+ * is silently ignored, `appPath` falls back to `xrePath`, and every
+ * `resource:///modules/…` import throws `Failed to load
+ * resource:///modules/<name>.sys.mjs` because xpcshell resolves the
+ * `resource:///` prefix one level above the real app root.
  *
  * ## Strategy
  *
  * 1. For each test path the operator handed us, find the nearest
  *    `xpcshell.toml`. If none exists, the test is not an xpcshell test and
- *    nothing to inject.
+ *    there is nothing to inject.
  * 2. Read the manifest's `[DEFAULT]` section. Look for `<appname>-appdir`
- *    first — if present, the harness already finds it and there's nothing to
- *    do. Fall back to `firefox-appdir`. This ordering matches upstream
- *    precedence and avoids overriding an operator who already migrated.
+ *    first — if present, the harness already finds it. Fall back to
+ *    `firefox-appdir`. This ordering matches upstream precedence and avoids
+ *    overriding an operator who already migrated.
  * 3. If only `firefox-appdir` is present and `appname != "firefox"`, compute
- *    the absolute app dir path against the active `obj-X/dist` tree
- *    (probing `dist/bin/<value>` first, then any `dist/<bundle>.app/Contents/
- *    Resources/<value>` for the macOS packaged layout) and return it as
- *    the value to pass to `--app-path`.
- * 4. If multiple test paths disagree on the resolved value (e.g. one
- *    manifest sets `browser`, another sets `xulrunner`), refuse injection
+ *    the absolute app dir path against the active `obj-X/dist` tree (probing
+ *    `dist/bin/<value>` first, then any
+ *    `dist/<bundle>.app/Contents/Resources/<value>` for the macOS packaged
+ *    layout) and return it as the value to pass to `--app-path`.
+ * 4. If multiple test paths disagree on the resolved value, refuse injection
  *    and return null — the operator can drop down to `--mach-arg`.
  *
- * Operator escape hatches: `--mach-arg=--app-path=…` always wins (handled in
- * test.ts; we skip injection when `--app-path=` already appears in the
+ * Operator escape hatch: `--mach-arg=--app-path=…` always wins (handled in
+ * test.ts, which skips injection when `--app-path=` already appears in the
  * forwarded args).
  */
 import { readdir, stat } from 'node:fs/promises';
@@ -106,15 +105,14 @@ function stripQuotes(raw) {
  * returns the absolute path of the first sibling `xpcshell.toml` found.
  * Stops at `engineDir` (inclusive) and returns null on miss.
  *
- * Special-cases `startPath` itself when it already ends with
- * `xpcshell.toml` — operators sometimes pass a manifest path directly.
+ * Special-cases `startPath` itself when it already ends with `xpcshell.toml`
+ * — operators sometimes pass a manifest path directly.
  *
  * When `startPath` is a DIRECTORY, the walk starts at the directory itself
- * (checking `<dir>/xpcshell.toml` first) rather than at its parent. Field
- * report (0.34.0 cycle): a directory whose own manifest is an
- * `xpcshell.toml` was classified non-xpcshell — the walk began at the
- * parent, missed the manifest, and `fireforge test <dir>` dispatched to
- * the mochitest runner, which found no mochitests.
+ * (checking `<dir>/xpcshell.toml` first) rather than at its parent.
+ * Starting at the parent misses a directory's own manifest, so
+ * `fireforge test <dir>` classifies it non-xpcshell and dispatches to the
+ * mochitest runner, which finds no mochitests.
  */
 export async function findNearestXpcshellManifest(engineDir, startPath) {
     const absStart = resolve(engineDir, startPath);
@@ -164,32 +162,27 @@ export async function readMozinfoAppname(objDirPath) {
     return 'firefox';
 }
 /**
- * Probes the obj-dir's `dist/` subtree for the absolute path that the
- * harness would have computed if the manifest key had been honoured.
- * Returns null when no candidate exists — better to skip injection
- * silently than to point the harness at a path that doesn't exist
- * (which fails with a different error than the original `firefox-appdir`
- * symptom and confuses triage).
+ * Probes the obj-dir's `dist/` subtree for the absolute path the harness
+ * would have computed if the manifest key had been honoured. Returns null
+ * when no candidate exists — better to skip injection silently than to point
+ * the harness at a path that does not exist, which fails with a different
+ * error than the original symptom and confuses triage.
  *
  * Probe order differs by host platform:
  *
- * - **macOS (`darwin`)**: prefer `<objDir>/dist/<App>.app/Contents/Resources/
- *   <value>` FIRST, then fall back to `<objDir>/dist/bin/<value>`.
- *   2026-04-24 eval Finding 8: on macOS `dist/bin` is symlinked to
+ * - **macOS (`darwin`)**: prefer
+ *   `<objDir>/dist/<App>.app/Contents/Resources/<value>` FIRST, then fall
+ *   back to `<objDir>/dist/bin/<value>`. On macOS `dist/bin` is symlinked to
  *   `dist/<App>.app/Contents/MacOS/` (the *binaries* directory), so
- *   `dist/bin/browser` actually resolves to `<App>.app/Contents/MacOS/
- *   browser/`. That is NOT where `resource:///modules/` is rooted — on
- *   macOS, `-a` for xpcshell must point at the `.app/Contents/Resources/
- *   <value>` subtree where modules / chrome.manifest live. Returning
- *   `dist/bin/browser` caused the injected `--app-path` to look
- *   successful (the info log showed it) but pointed at a directory
- *   without the modules tree, so every `resource:///modules/…` import
- *   still threw.
- * - **non-macOS**: keep the historical order — `dist/bin/<value>` first,
+ *   `dist/bin/browser` resolves to `<App>.app/Contents/MacOS/browser/` —
+ *   NOT where `resource:///modules/` is rooted. Injecting that path looks
+ *   successful in the log but points at a directory with no modules tree, so
+ *   every `resource:///modules/…` import still throws.
+ * - **non-macOS**: `dist/bin/<value>` first,
  *   `.app/Contents/Resources/<value>` as fallback.
  *
- * On both platforms the final `.app` fallback iterates every `*.app`
- * entry because a rebranded fork may pick an arbitrary app name.
+ * On both platforms the final `.app` fallback iterates every `*.app` entry
+ * because a rebranded fork may pick an arbitrary app name.
  */
 export async function resolveAbsoluteAppPath(objDirAbs, relativeAppdir) {
     const distBinCandidate = join(objDirAbs, 'dist', 'bin', relativeAppdir);