@hominis/fireforge 0.45.0 → 0.46.1

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

@@ -2,7 +2,7 @@
 /**
  * Minimal Markdown pipe-table parser/writer used by token-manager.
  *
- * This is **not** a general Markdown parser. It understands exactly the
+ * This is not a general Markdown parser. It understands exactly the
  * slice of GitHub-flavoured Markdown that FireForge emits into token docs:
  *
  *   - Leading `|` per row, trailing `|` optional.
@@ -13,10 +13,10 @@
  *   - Literal `|` and `\` inside a cell are expressed as `\|` and `\\`
  *     respectively. The parser treats any other backslash as a literal
  *     so prose-style backslashes in cell values (e.g. a Windows path)
- *     still round-trip. Unescaping happens at split time; serialization
+ *     still round-trip. Unescaping happens at split time. Serialization
  *     re-applies escapes so round-trips are exact for well-formed input.
  *
- * The parser returns **positional metadata** (`startLine`, `endLine`) so
+ * The parser returns positional metadata (`startLine`, `endLine`) so
  * callers can splice the table back into the surrounding document by
  * range instead of hand-rolled line counters. Mutation operations return
  * a fresh line array rather than mutating in place, matching the rest of
@@ -25,7 +25,7 @@
  * Fallback tolerance: rows with more cells than the header get their
  * overflow merged into the last column (using a literal `|` separator
  * between the merged values). This is for the rare case where a FireForge
- * writer emits an unescaped pipe — the parser still produces a consistent
+ * writer emits an unescaped pipe. The parser still produces a consistent
  * cell count rather than desynchronising the table. On re-serialize the
  * merged cell's literal pipes are escaped, so a malformed input becomes
  * a well-formed output after one round trip.
@@ -38,8 +38,8 @@
 const SEPARATOR_ROW = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)+\|?\s*$/;
 /**
  * Returns `true` if the given line looks like a table row (starts with
- * `|`, ignoring leading whitespace). Does not validate cell contents —
- * that is the caller's job.
+ * `|`, ignoring leading whitespace). Does not validate cell contents.
+ * That is the caller's job.
  */
 function isPipeRow(line) {
     return /^\s*\|/.test(line);
@@ -79,11 +79,11 @@ function splitRow(row) {
         current += ch ?? '';
     }
     cells.push(current);
-    // Leading `|` gives an empty first segment; drop it.
+    // Leading `|` gives an empty first segment, so drop it.
     if (cells.length > 0 && cells[0] === '') {
         cells.shift();
     }
-    // Trailing `|` gives an empty last segment; drop it.
+    // Trailing `|` gives an empty last segment, so drop it.
     if (cells.length > 0 && cells[cells.length - 1] === '') {
         cells.pop();
     }
@@ -93,7 +93,7 @@ function splitRow(row) {
  * Escapes a cell value so `serializeRow`'s pipe delimiters can be told
  * apart from literal `|` inside a cell on re-parse. `\` is escaped first
  * (to `\\`) so that the subsequent `|` → `\|` substitution cannot produce
- * an already-escaped sequence by accident — i.e. a cell containing
+ * an already-escaped sequence by accident. A cell containing
  * literal `\` followed by literal `|` round-trips as `\\\|`, which
  * unescape-on-split reads back as `\` + `|`, not as `\|`.
  */
@@ -114,7 +114,7 @@ function fitRowToColumns(cells, columnCount) {
     if (cells.length < columnCount) {
         return [...cells, ...Array(columnCount - cells.length).fill('')];
     }
-    // cells.length > columnCount — merge overflow into the last column.
+    // cells.length > columnCount: merge overflow into the last column.
     const kept = cells.slice(0, columnCount - 1);
     const tail = cells.slice(columnCount - 1).join(' | ');
     return [...kept, tail];
@@ -160,7 +160,7 @@ export function findNextTable(lines, fromLine) {
             const rowLine = lines[j] ?? '';
             if (!isPipeRow(rowLine))
                 break;
-            // Another separator line would signal a malformed table — bail.
+            // Another separator line would signal a malformed table, so bail.
             if (SEPARATOR_ROW.test(rowLine))
                 break;
             rows.push(fitRowToColumns(splitRow(rowLine), headers.length));
@@ -171,7 +171,7 @@ export function findNextTable(lines, fromLine) {
     return null;
 }
 /**
- * Returns the first table whose header contains **all** of the provided
+ * Returns the first table whose header contains all of the provided
  * column names (case-sensitive, order-insensitive). Useful when several
  * pipe tables share a document and you want to select "the one with a
  * Mode column".
@@ -190,7 +190,7 @@ export function findTableByColumns(lines, requiredColumns) {
     }
 }
 /**
- * Returns the first table that appears **after** a heading matching the
+ * Returns the first table that appears after a heading matching the
  * given regex. The heading regex is applied to raw lines (no trimming)
  * so callers that want leading whitespace flexibility should include
  * `^\s*` or `^#+\s*` as appropriate.
@@ -217,7 +217,7 @@ export function serializeRow(cells) {
 }
 /**
  * Inserts a new row into `table.rows` at the given zero-based index. A
- * negative index counts from the end; `Infinity` appends. Mutates the
+ * negative index counts from the end. `Infinity` appends. Mutates the
  * table object so callers using {@link rewriteTableRows} see the update.
  */
 export function insertRow(table, cells, index) {

package/dist/src/core/mochitest-server-port.d.ts

@@ -6,24 +6,24 @@ export declare const DEFAULT_MOCHITEST_SERVER_PORT = 8888;
  * `server.js`, launched from an objdir.
  *
  * Both halves are required. `server.js` alone is one of the most common
- * filenames in existence — a developer's unrelated Node service must never
- * be mistaken for harness debris and offered up for termination — so the
- * command line must ALSO show the xpcshell/objdir provenance that only the
+ * filenames there is, and a developer's unrelated Node service must never
+ * be mistaken for harness debris and offered up for termination. So the
+ * command line must also show the xpcshell/objdir provenance that only the
  * harness's httpd has.
  */
 export declare function isMochitestServerHolder(holder: MarionettePortHolder): boolean;
 /**
- * Refuses a mochitest dispatch when the harness's server port is held, and
- * — only for a recognized stale harness httpd, and only when the operator
- * opted in — terminates it first.
+ * Refuses a mochitest dispatch when the harness's server port is held. It
+ * terminates the holder first only for a recognized stale harness httpd,
+ * and only when the operator opted in.
  *
- * An UNRECOGNIZED listener is a refusal too, never a kill. Refusing is the
+ * An unrecognized listener is a refusal too, never a kill. Refusing is the
  * kinder outcome: mochitest cannot bind the port either way, so the choice
  * is between a one-line refusal now and a 370 s stall whose signature says
  * nothing about ports. But FireForge has no business killing a process it
  * cannot attribute to the harness.
  *
- * Best-effort by construction: {@link probeMarionettePort} reports an
+ * Best effort: {@link probeMarionettePort} reports an
  * unprobeable port as free, so a host without `lsof` runs exactly as before.
  *
  * @param port - Port to probe (default {@link DEFAULT_MOCHITEST_SERVER_PORT})

package/dist/src/core/mochitest-server-port.js

@@ -4,23 +4,23 @@
  *
  * The mochitest harness serves its test manifest from an xpcshell-hosted
  * httpd (`server.js`) on `127.0.0.1:8888`. When a previous run is killed
- * between browser launch and teardown, that server can survive — sometimes
- * wedged at 100% CPU and unkillable by the harness's own SIGKILL — and it
+ * between browser launch and teardown, that server can survive (sometimes
+ * wedged at 100% CPU and unkillable by the harness's own SIGKILL) and it
  * keeps the port.
  *
  * The next run then does something much worse than failing: its fresh
- * browser connects to the ZOMBIE server, which cannot serve the new
+ * browser connects to the zombie server, which cannot serve the new
  * manifest, so the run stalls between browser startup and `TEST_START` and
  * dies on the 370 s no-output timeout with `Ran 0 checks`. Nothing in that
  * signature names the port, so the failure survives fresh builds and reads
- * as a defect in the change under test — one downstream report spent a
+ * as a defect in the change under test. One downstream report spent a
  * multi-hour bisect on it before `lsof -nP -iTCP:8888` gave the answer in
  * one line.
  *
  * `--kill-stale-marionette` never covered this: it clears the browser and
  * the Marionette control port, and the httpd is neither. This preflight is
- * the missing half, and it deliberately reuses {@link probeMarionettePort},
- * which is port-generic, rather than growing a second probe.
+ * the missing half, and it reuses {@link probeMarionettePort}, which is
+ * port-generic, rather than growing a second probe.
  */
 import { GeneralError } from '../errors/base.js';
 import { exec } from '../utils/process.js';
@@ -32,9 +32,9 @@ export const DEFAULT_MOCHITEST_SERVER_PORT = 8888;
  * `server.js`, launched from an objdir.
  *
  * Both halves are required. `server.js` alone is one of the most common
- * filenames in existence — a developer's unrelated Node service must never
- * be mistaken for harness debris and offered up for termination — so the
- * command line must ALSO show the xpcshell/objdir provenance that only the
+ * filenames there is, and a developer's unrelated Node service must never
+ * be mistaken for harness debris and offered up for termination. So the
+ * command line must also show the xpcshell/objdir provenance that only the
  * harness's httpd has.
  */
 export function isMochitestServerHolder(holder) {
@@ -44,17 +44,17 @@ export function isMochitestServerHolder(holder) {
     return /\bxpcshell\b/.test(line) || /\/obj-[^/\s]*\//.test(line) || /\b_tests\b/.test(line);
 }
 /**
- * Refuses a mochitest dispatch when the harness's server port is held, and
- * — only for a recognized stale harness httpd, and only when the operator
- * opted in — terminates it first.
+ * Refuses a mochitest dispatch when the harness's server port is held. It
+ * terminates the holder first only for a recognized stale harness httpd,
+ * and only when the operator opted in.
  *
- * An UNRECOGNIZED listener is a refusal too, never a kill. Refusing is the
+ * An unrecognized listener is a refusal too, never a kill. Refusing is the
  * kinder outcome: mochitest cannot bind the port either way, so the choice
  * is between a one-line refusal now and a 370 s stall whose signature says
  * nothing about ports. But FireForge has no business killing a process it
  * cannot attribute to the harness.
  *
- * Best-effort by construction: {@link probeMarionettePort} reports an
+ * Best effort: {@link probeMarionettePort} reports an
  * unprobeable port as free, so a host without `lsof` runs exactly as before.
  *
  * @param port - Port to probe (default {@link DEFAULT_MOCHITEST_SERVER_PORT})
@@ -100,8 +100,8 @@ export function describeMochitestServerRefusal(port, holder, recognized) {
     const killHint = process.platform === 'win32'
         ? `Stop-Process -Id ${holder.pid} -Force`
         : `kill -9 ${holder.pid}`;
-    const evidence = `The mochitest server port ${String(port)} is already held by ${holder.command} ` +
-        `(PID ${String(holder.pid)}).\n` +
+    const evidence = `The mochitest server port ${port} is already held by ${holder.command} ` +
+        `(PID ${holder.pid}).\n` +
         `  command: ${holder.commandLine}\n` +
         "  A browser launched now would connect to THAT server, which cannot serve this run's " +
         'manifest — the run would stall before TEST_START and die on the no-output timeout with ' +
@@ -115,5 +115,5 @@ export function describeMochitestServerRefusal(port, holder, recognized) {
     return (evidence +
         "  This is NOT the mochitest harness's server.js, so FireForge will not offer to kill it. " +
         `Stop the holder yourself with "${killHint}" if it is yours, or free the port, then retry. ` +
-        `Diagnose with "lsof -nP -iTCP:${String(port)}".`);
+        `Diagnose with "lsof -nP -iTCP:${port}".`);
 }

package/dist/src/core/module-resolution-preflight.d.ts

@@ -3,20 +3,20 @@
  *
  * An `.sys.mjs` that a packaged module imports but whose `EXTRA_JS_MODULES`
  * registration never landed kills every xpcshell suite with `xpcshell return
- * code: -11` and ZERO output — no import error, no stack, nothing. The
+ * code: -11` and no output at all: no import error, no stack, nothing. The
  * queue-level `unregistered-system-module` check catches one shape of this:
- * a module NEWLY CREATED by a patch in the projected queue. The other shape
- * — modules imported from an ALREADY-EXISTING module before their moz.build
- * lines land — slips past it entirely.
+ * a module newly created by a patch in the projected queue. The other shape,
+ * modules imported from an already-existing module before their moz.build
+ * lines land, slips past it entirely.
  *
- * This preflight closes that gap by asking the question against the ENGINE
+ * This preflight closes that gap by asking the question against the engine
  * rather than against a projected diff: for every `resource:///modules/…`
  * specifier imported by any queue-owned module, does the module it names
  * exist, and is it registered in a moz.build that covers it?
  *
  * Scope is the queue-owned file set on purpose. A specifier that resolves to
- * no owned file is an UPSTREAM Firefox module, which FireForge does not
- * police and cannot cheaply enumerate; policing only what the fork owns is
+ * no owned file is an upstream Firefox module, which FireForge does not
+ * police and cannot cheaply enumerate. Policing only what the fork owns is
  * both the actionable set and the one that produces real incidents.
  */
 /** Why a queue-owned module import does not resolve to a packaged module. */
@@ -38,7 +38,7 @@ export interface UnresolvedModuleImport {
  *
  * @param engineDir - Path to the engine checkout
  * @param ownedFiles - Engine-relative paths the patch queue owns
- * @returns Findings sorted by module path; empty when everything resolves
+ * @returns Findings sorted by module path. Empty when everything resolves
  */
 export declare function findUnresolvedSystemModuleImports(engineDir: string, ownedFiles: readonly string[]): Promise<UnresolvedModuleImport[]>;
 /**

package/dist/src/core/module-resolution-preflight.js

@@ -4,20 +4,20 @@
  *
  * An `.sys.mjs` that a packaged module imports but whose `EXTRA_JS_MODULES`
  * registration never landed kills every xpcshell suite with `xpcshell return
- * code: -11` and ZERO output — no import error, no stack, nothing. The
+ * code: -11` and no output at all: no import error, no stack, nothing. The
  * queue-level `unregistered-system-module` check catches one shape of this:
- * a module NEWLY CREATED by a patch in the projected queue. The other shape
- * — modules imported from an ALREADY-EXISTING module before their moz.build
- * lines land — slips past it entirely.
+ * a module newly created by a patch in the projected queue. The other shape,
+ * modules imported from an already-existing module before their moz.build
+ * lines land, slips past it entirely.
  *
- * This preflight closes that gap by asking the question against the ENGINE
+ * This preflight closes that gap by asking the question against the engine
  * rather than against a projected diff: for every `resource:///modules/…`
  * specifier imported by any queue-owned module, does the module it names
  * exist, and is it registered in a moz.build that covers it?
  *
  * Scope is the queue-owned file set on purpose. A specifier that resolves to
- * no owned file is an UPSTREAM Firefox module, which FireForge does not
- * police and cannot cheaply enumerate; policing only what the fork owns is
+ * no owned file is an upstream Firefox module, which FireForge does not
+ * police and cannot cheaply enumerate. Policing only what the fork owns is
  * both the actionable set and the one that produces real incidents.
  */
 import { dirname, join } from 'node:path';
@@ -47,7 +47,7 @@ async function readIfPresent(path) {
  * True when some `moz.build` at or above `moduleRelPath`'s directory (up
  * to, and including, the engine root) mentions the module's basename.
  *
- * Walking ancestors — rather than checking only the sibling `moz.build` —
+ * Walking ancestors, rather than checking only the sibling `moz.build`,
  * matches how Mozilla's build system actually works: a module list may sit
  * in a parent directory's `moz.build` with a path-qualified entry. The
  * check is a quoted-basename match for the same reason the queue-level
@@ -59,7 +59,7 @@ async function isRegisteredInAncestorMozBuild(engineDir, moduleRelPath, mozBuild
     // The entry may be the bare basename (`"Foo.sys.mjs"`, sibling
     // moz.build) or path-qualified relative to the moz.build that declares
     // it (`"sub/Foo.sys.mjs"`, ancestor moz.build). Both are the same
-    // registration; anchor on the closing quote and require a path boundary
+    // registration. Anchor on the closing quote and require a path boundary
     // so `NotFoo.sys.mjs` cannot satisfy `Foo.sys.mjs`.
     const quotedLeaf = new RegExp(`["'](?:[^"']*/)?${escapeRegex(leaf)}["']`);
     let dir = dirname(moduleRelPath);
@@ -86,7 +86,7 @@ async function isRegisteredInAncestorMozBuild(engineDir, moduleRelPath, mozBuild
  *
  * @param engineDir - Path to the engine checkout
  * @param ownedFiles - Engine-relative paths the patch queue owns
- * @returns Findings sorted by module path; empty when everything resolves
+ * @returns Findings sorted by module path. Empty when everything resolves
  */
 export async function findUnresolvedSystemModuleImports(engineDir, ownedFiles) {
     const owned = [...new Set(ownedFiles)];
@@ -110,7 +110,7 @@ export async function findUnresolvedSystemModuleImports(engineDir, ownedFiles) {
         const suffix = moduleSourceSuffix(specifier);
         if (suffix === undefined)
             continue;
-        // Only fork-owned targets are policed; anything else is upstream.
+        // Only fork-owned targets are policed. Anything else is upstream.
         const target = owned.find((file) => file.endsWith(suffix));
         if (target === undefined)
             continue;

package/dist/src/core/moz-manifest-helpers.d.ts

@@ -1,7 +1,7 @@
 import type { MozBuildToken } from './moz-manifest-tokenizers.js';
 /**
  * Ordering comparator matching mozbuild's `StrictOrderingOnAppendList`
- * (`mozbuild.util.UnsortedError`): entries are compared **case-insensitively**,
+ * (`mozbuild.util.UnsortedError`): entries are compared case-insensitively,
  * so `HominisAppearanceController` (`appe`) sorts before
  * `HominisAppMenuIntegration` (`appm`) even though a raw byte comparison
  * places the uppercase `M` (0x4D) before the lowercase `e` (0x65).
@@ -26,11 +26,11 @@ export declare function findAlphabeticalMozBuildPosition(tokens: MozBuildToken[]
  *
  * Shared by the two jar.mn registrars (browser content, shared CSS), which
  * differ only in the sort pattern, the sort key and the "could not find the
- * section" message, so the anchor-fallback semantics — silently falling back
- * rather than refusing, and reporting `afterFallback` so the caller can say
- * so — are defined once.
+ * section" message, so the anchor-fallback semantics are defined once:
+ * silently fall back rather than refuse, and report `afterFallback` so the
+ * caller can say so.
  *
- * Deliberately jar.mn-specific: the moz.build list form has no `after` anchor
+ * This helper is jar.mn-specific: the moz.build list form has no `after` anchor
  * and no section concept, so a single generic helper over both families
  * would carry parameters that are meaningless on one side. See
  * {@link insertMozBuildListEntry} for its twin.
@@ -58,11 +58,11 @@ export declare function insertJarMnEntry(content: string, entry: string, options
  * manifests), which differ only in the list pattern, the sort key and the
  * refusal message.
  *
- * `tokenizeMozBuildList` **mutates `lines` in place** when it normalizes the
+ * `tokenizeMozBuildList` mutates `lines` in place when it normalizes the
  * single-line `FOO += []` form into the multi-line shape, and that rewrite is
  * what makes the caller's `splice` land inside the list body. The splice
  * below therefore has to run against the same array the tokenizer was
- * handed; a wrapper that tokenized a copy would silently break it.
+ * handed. A wrapper that tokenized a copy would silently break it.
  *
  * @param content - Full moz.build text
  * @param entry - The already-formatted line to insert

package/dist/src/core/moz-manifest-helpers.js

@@ -4,7 +4,7 @@ import { escapeRegex } from '../utils/regex.js';
 import { tokenizeJarMn, tokenizeMozBuildList } from './moz-manifest-tokenizers.js';
 /**
  * Ordering comparator matching mozbuild's `StrictOrderingOnAppendList`
- * (`mozbuild.util.UnsortedError`): entries are compared **case-insensitively**,
+ * (`mozbuild.util.UnsortedError`): entries are compared case-insensitively,
  * so `HominisAppearanceController` (`appe`) sorts before
  * `HominisAppMenuIntegration` (`appm`) even though a raw byte comparison
  * places the uppercase `M` (0x4D) before the lowercase `e` (0x65).
@@ -91,11 +91,11 @@ export function findAlphabeticalMozBuildPosition(tokens, newKey) {
  *
  * Shared by the two jar.mn registrars (browser content, shared CSS), which
  * differ only in the sort pattern, the sort key and the "could not find the
- * section" message, so the anchor-fallback semantics — silently falling back
- * rather than refusing, and reporting `afterFallback` so the caller can say
- * so — are defined once.
+ * section" message, so the anchor-fallback semantics are defined once:
+ * silently fall back rather than refuse, and report `afterFallback` so the
+ * caller can say so.
  *
- * Deliberately jar.mn-specific: the moz.build list form has no `after` anchor
+ * This helper is jar.mn-specific: the moz.build list form has no `after` anchor
  * and no section concept, so a single generic helper over both families
  * would carry parameters that are meaningless on one side. See
  * {@link insertMozBuildListEntry} for its twin.
@@ -140,11 +140,11 @@ export function insertJarMnEntry(content, entry, options) {
  * manifests), which differ only in the list pattern, the sort key and the
  * refusal message.
  *
- * `tokenizeMozBuildList` **mutates `lines` in place** when it normalizes the
+ * `tokenizeMozBuildList` mutates `lines` in place when it normalizes the
  * single-line `FOO += []` form into the multi-line shape, and that rewrite is
  * what makes the caller's `splice` land inside the list body. The splice
  * below therefore has to run against the same array the tokenizer was
- * handed; a wrapper that tokenized a copy would silently break it.
+ * handed. A wrapper that tokenized a copy would silently break it.
  *
  * @param content - Full moz.build text
  * @param entry - The already-formatted line to insert

package/dist/src/core/moz-manifest-register.d.ts

@@ -1,5 +1,5 @@
 /**
- * Manifest registration barrel — re-exports all registration targets
+ * Manifest registration barrel. Re-exports all registration targets
  * and the shared RegisterResult interface (which lives in
  * `register-result.ts` so the leaf modules can import it without
  * creating a cycle through this barrel).

package/dist/src/core/moz-manifest-register.js

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
- * Manifest registration barrel — re-exports all registration targets
+ * Manifest registration barrel. Re-exports all registration targets
  * and the shared RegisterResult interface (which lives in
  * `register-result.ts` so the leaf modules can import it without
  * creating a cycle through this barrel).
@@ -15,7 +15,7 @@ export { deregisterTestManifest, registerTestManifest } from './register-browser
 export { registerFireForgeModule } from './register-module.js';
 export { registerSharedCSS } from './register-shared-css.js';
 // ---------------------------------------------------------------------------
-// toolkit/content/jar.mn — widget registration
+// toolkit/content/jar.mn: widget registration
 // ---------------------------------------------------------------------------
 /**
  * Registers a widget file (mjs or css) in toolkit/content/jar.mn.

package/dist/src/core/moz-manifest-rules.js

@@ -3,6 +3,7 @@ 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 { normalizePathSlashes } from '../utils/paths.js';
 import { escapeRegex } from '../utils/regex.js';
 import { getProjectPaths, loadConfig } from './config.js';
 import { registerBrowserContent, registerFireForgeModule, registerSharedCSS, registerTestManifest, registerToolkitWidget, } from './moz-manifest-register.js';
@@ -25,8 +26,8 @@ export function getRules(binaryName, createManifest = false) {
             supportsAfter: true,
         },
         {
-            // `.inc.xhtml` fragments under browser/base/content/ are deliberately
-            // excluded: they are consumed via `#include` from a registered chrome
+            // `.inc.xhtml` fragments under browser/base/content/ are excluded on
+            // purpose: they are consumed via `#include` from a registered chrome
             // 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`
@@ -45,8 +46,8 @@ export function getRules(binaryName, createManifest = false) {
             supportsAfter: true,
         },
         {
-            // Fork-owned browser.toml manifests at ARBITRARY depth under
-            // browser/base/content/test/ — a one-level pattern rejects nested
+            // Fork-owned browser.toml manifests at any depth under
+            // 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),
@@ -72,66 +73,69 @@ export function getRules(binaryName, createManifest = false) {
             // 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
+            // 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
+            // Both groups are guaranteed by the pattern, so slice avoids dead
             // fallback branches.
             extractArgs: (m) => m.slice(1, 3),
             supportsAfter: false,
         },
     ];
 }
-async function isSharedCSSRegistered(engineDir, fileName) {
-    const manifestPath = join(engineDir, 'browser/themes/shared/jar.inc.mn');
+/**
+ * Reads an engine manifest and reports whether it contains any of `needles`.
+ *
+ * The five registration probes below share this shape: resolve the manifest
+ * relative to the engine, refuse with the manifest's own path when it is
+ * missing, then substring-match the entry each registrar writes.
+ *
+ * @param engineDir - Path to the engine directory
+ * @param manifestRel - Engine-relative manifest path (forward slashes, and
+ *   also the path named in the refusal message)
+ * @param needles - Entry forms that count as registered
+ * @returns True when the manifest contains at least one needle
+ * @throws GeneralError when the manifest does not exist
+ */
+async function manifestIncludes(engineDir, manifestRel, needles) {
+    const manifestPath = join(engineDir, manifestRel);
     if (!(await pathExists(manifestPath))) {
-        throw new GeneralError('Manifest not found: browser/themes/shared/jar.inc.mn');
+        throw new GeneralError(`Manifest not found: ${manifestRel}`);
     }
-    const name = basename(fileName, '.css');
     const content = await readText(manifestPath);
-    // `register` writes the canonical `skin/classic/browser/<name>.css` form;
+    return needles.some((needle) => content.includes(needle));
+}
+async function isSharedCSSRegistered(engineDir, fileName) {
+    const name = basename(fileName, '.css');
+    // `register` writes the canonical `skin/classic/browser/<name>.css` form.
     // `furnace chrome-doc create` writes a `content/browser/<name>.css` entry
     // because the CSS is loaded by a chrome document via a `chrome://browser/
     // content/<name>.css` URI. Match either prefix so paths registered by the
     // chrome-doc scaffolder are not flagged as "potentially unregistered" by
     // `status` and so a re-run of `register` against the same file recognises
     // the existing entry instead of proposing a duplicate.
-    return (content.includes(`skin/classic/browser/${name}.css`) ||
-        content.includes(`content/browser/${name}.css`));
+    return manifestIncludes(engineDir, 'browser/themes/shared/jar.inc.mn', [
+        `skin/classic/browser/${name}.css`,
+        `content/browser/${name}.css`,
+    ]);
 }
 async function isBrowserContentRegistered(engineDir, fileName) {
-    const manifestPath = join(engineDir, 'browser/base/jar.mn');
-    if (!(await pathExists(manifestPath))) {
-        throw new GeneralError('Manifest not found: browser/base/jar.mn');
-    }
-    const content = await readText(manifestPath);
-    return content.includes(`content/browser/${fileName}`);
+    return manifestIncludes(engineDir, 'browser/base/jar.mn', [`content/browser/${fileName}`]);
 }
 async function isTestManifestRegistered(engineDir, testDir) {
-    const manifestPath = join(engineDir, 'browser/base/moz.build');
-    if (!(await pathExists(manifestPath))) {
-        throw new GeneralError('Manifest not found: browser/base/moz.build');
-    }
-    const content = await readText(manifestPath);
-    return content.includes(`content/test/${testDir}/browser.toml`);
+    return manifestIncludes(engineDir, 'browser/base/moz.build', [
+        `content/test/${testDir}/browser.toml`,
+    ]);
 }
 async function isFireForgeModuleRegistered(engineDir, fileName, moduleDir) {
-    const manifestPath = join(engineDir, moduleDir, 'moz.build');
-    if (!(await pathExists(manifestPath))) {
-        throw new GeneralError(`Manifest not found: ${moduleDir}/moz.build`);
-    }
-    const content = await readText(manifestPath);
-    return content.includes(`"${fileName}"`);
+    return manifestIncludes(engineDir, `${moduleDir}/moz.build`, [`"${fileName}"`]);
 }
 async function isToolkitWidgetRegistered(engineDir, _tagName, fileName) {
-    const manifestPath = join(engineDir, 'toolkit/content/jar.mn');
-    if (!(await pathExists(manifestPath))) {
-        throw new GeneralError('Manifest not found: toolkit/content/jar.mn');
-    }
-    const content = await readText(manifestPath);
-    return content.includes(`content/global/elements/${fileName}`);
+    return manifestIncludes(engineDir, 'toolkit/content/jar.mn', [
+        `content/global/elements/${fileName}`,
+    ]);
 }
 /**
  * Checks if a file path matches any known registrable pattern.
@@ -140,7 +144,7 @@ async function isToolkitWidgetRegistered(engineDir, _tagName, fileName) {
  * @returns True if the file matches a known registration pattern
  */
 export function matchesRegistrablePattern(filePath, binaryName) {
-    const normalized = filePath.replace(/\\/g, '/');
+    const normalized = normalizePathSlashes(filePath);
     const rules = getRules(binaryName);
     return rules.some((rule) => rule.pattern.test(normalized));
 }
@@ -151,7 +155,7 @@ function getUnregistrableAdvice(filePath) {
     }
     // `.inc.xhtml` fragments live under browser/base/content/ but are
     // consumed via `#include` from a registered chrome document (browser.xhtml
-    // by default; a fork's custom top-level doc when `wire --dom-target` is
+    // by default, or a fork's custom top-level doc when `wire --dom-target` is
     // set). The preprocessor resolves the include at packaging time, so the
     // fragment never needs its own chrome URI entry in jar.mn. Give the
     // operator the actionable `wire` path instead of letting the generic
@@ -165,7 +169,7 @@ function getUnregistrableAdvice(filePath) {
     // xpcshell.toml manifests scaffolded by `furnace create --test-style
     // xpcshell` or `furnace chrome-doc create --with-tests` live under
     // `browser/base/content/test/<binary-name>-xpcshell/<component>/`. The
-    // scaffold intentionally does NOT auto-register — wiring
+    // scaffold does not auto-register, because 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 for a path
@@ -197,7 +201,7 @@ export async function isFileRegistered(root, filePath) {
     const { engine: engineDir } = getProjectPaths(root);
     const config = await loadConfig(root);
     const rules = getRules(config.binaryName);
-    const normalizedPath = filePath.replace(/\\/g, '/');
+    const normalizedPath = normalizePathSlashes(filePath);
     for (const rule of rules) {
         const match = normalizedPath.match(rule.pattern);
         if (match) {
@@ -237,7 +241,7 @@ export async function registerFile(root, filePath, dryRun = false, after, option
     const config = await loadConfig(root);
     const rules = getRules(config.binaryName, options.createManifest === true);
     // Normalize path separators
-    const normalizedPath = filePath.replace(/\\/g, '/');
+    const normalizedPath = normalizePathSlashes(filePath);
     for (const rule of rules) {
         const match = normalizedPath.match(rule.pattern);
         if (match) {

package/dist/src/core/moz-manifest-tokenizers.js

@@ -59,7 +59,7 @@ export function tokenizeMozBuildList(lines, listPattern) {
             if (listPattern.test(raw)) {
                 // Single-line empty-list handling: a fresh scaffold sometimes
                 // writes `EXTRA_JS_MODULES += []` on one line, which a tokenizer
-                // looking for a line starting with `]` never closes — leaving
+                // 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.
                 //