@hominis/fireforge 0.33.0 → 0.34.1

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

@@ -10,7 +10,7 @@
  * Ties on the lower-cased key fall back to byte order so the comparison is
  * total and stable.
  */
-function mozbuildSortCompare(a, b) {
+export function mozbuildSortCompare(a, b) {
     const la = a.toLowerCase();
     const lb = b.toLowerCase();
     if (la < lb)

package/dist/src/core/manifest-rules.d.ts

@@ -10,8 +10,14 @@ export interface PatternRule {
     /** Extract arguments from the regex match */
     extractArgs: (match: RegExpMatchArray) => string[];
 }
-/** Returns manifest registration rules for the supported engine file patterns. */
-export declare function getRules(binaryName: string): PatternRule[];
+/**
+ * Returns manifest registration rules for the supported engine file
+ * patterns. `createManifest` (from `register --create-manifest`) lets the
+ * module and xpcshell-test rules scaffold a missing manifest (directory
+ * moz.build / xpcshell.toml) and wire the parent chain instead of failing
+ * with "Manifest not found".
+ */
+export declare function getRules(binaryName: string, createManifest?: boolean): PatternRule[];
 /**
  * Checks if a file path matches any known registrable pattern.
  * @param filePath - Path relative to engine/
@@ -34,6 +40,10 @@ export declare function isFileRegistered(root: string, filePath: string): Promis
  * @param filePath - Path relative to engine/
  * @param dryRun - If true, return what would be done without writing
  * @param after - Optional substring to place entry after (instead of alphabetical)
+ * @param options - `createManifest` scaffolds a missing manifest (directory
+ *   moz.build / xpcshell.toml) and wires the parent chain instead of failing
  * @returns Registration result
  */
-export declare function registerFile(root: string, filePath: string, dryRun?: boolean, after?: string): Promise<RegisterResult>;
+export declare function registerFile(root: string, filePath: string, dryRun?: boolean, after?: string, options?: {
+    createManifest?: boolean;
+}): Promise<RegisterResult>;

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

@@ -5,8 +5,15 @@ import { pathExists, readText } from '../utils/fs.js';
 import { escapeRegex } from '../utils/regex.js';
 import { getProjectPaths, loadConfig } from './config.js';
 import { registerBrowserContent, registerFireForgeModule, registerSharedCSS, registerTestManifest, registerToolkitWidget, } from './manifest-register.js';
-/** Returns manifest registration rules for the supported engine file patterns. */
-export function getRules(binaryName) {
+import { isXpcshellTestRegistered, registerXpcshellTest } from './register-xpcshell-test.js';
+/**
+ * Returns manifest registration rules for the supported engine file
+ * patterns. `createManifest` (from `register --create-manifest`) lets the
+ * module and xpcshell-test rules scaffold a missing manifest (directory
+ * moz.build / xpcshell.toml) and wire the parent chain instead of failing
+ * with "Manifest not found".
+ */
+export function getRules(binaryName, createManifest = false) {
     const moduleDir = `browser/modules/${binaryName}`;
     return [
         {
@@ -39,7 +46,10 @@ export function getRules(binaryName) {
             extractArgs: (m) => [m[1] ?? ''],
         },
         {
-            pattern: /^browser\/base\/content\/test\/([^/]+)\/browser\.toml$/,
+            // Fork-owned browser.toml manifests at ARBITRARY depth under
+            // browser/base/content/test/ (0.34.0 field report: only one level
+            // was supported, rejecting nested browser-chrome manifests).
+            pattern: /^browser\/base\/content\/test\/((?:[^/]+\/)*[^/]+)\/browser\.toml$/,
             isRegistered: (_engineDir, testDir) => isTestManifestRegistered(_engineDir, testDir),
             register: (_engineDir, _after, dryRun, testDir) => registerTestManifest(_engineDir, testDir, dryRun),
             extractArgs: (m) => [m[1] ?? ''],
@@ -47,7 +57,7 @@ export function getRules(binaryName) {
         {
             pattern: new RegExp(`^browser/modules/${escapeRegex(binaryName)}/(.+\\.sys\\.mjs)$`),
             isRegistered: (_engineDir, fileName) => isFireForgeModuleRegistered(_engineDir, fileName, moduleDir),
-            register: (_engineDir, _after, dryRun, fileName) => registerFireForgeModule(_engineDir, fileName, moduleDir, dryRun),
+            register: (_engineDir, _after, dryRun, fileName) => registerFireForgeModule(_engineDir, fileName, moduleDir, dryRun, createManifest),
             extractArgs: (m) => [m[1] ?? ''],
         },
         {
@@ -56,6 +66,20 @@ export function getRules(binaryName) {
             register: (_engineDir, _after, dryRun, tagName, fileName) => registerToolkitWidget(_engineDir, tagName, fileName, dryRun),
             extractArgs: (m) => [m[1] ?? '', m[2] ?? ''],
         },
+        {
+            // xpcshell test files (0.34.0 field report: rejected as "Unknown
+            // file pattern"). Any `test_*.js` outside browser/base/content/test/
+            // (which stays browser-chrome territory with its browser.toml
+            // guidance) registers into the directory's xpcshell.toml; with
+            // --create-manifest a missing manifest is scaffolded and wired via
+            // XPCSHELL_TESTS_MANIFESTS.
+            pattern: /^(?!browser\/base\/content\/test\/)(.+)\/(test_[^/]+\.js)$/,
+            isRegistered: (engineDir, dirRel, fileName) => isXpcshellTestRegistered(engineDir, dirRel, fileName),
+            register: (engineDir, _after, dryRun, dirRel, fileName) => registerXpcshellTest(engineDir, dirRel, fileName, dryRun, createManifest),
+            // Both groups are guaranteed by the pattern; slice avoids dead
+            // fallback branches.
+            extractArgs: (m) => m.slice(1, 3),
+        },
     ];
 }
 async function isSharedCSSRegistered(engineDir, fileName) {
@@ -149,7 +173,8 @@ function getUnregistrableAdvice(filePath) {
         return (`xpcshell.toml manifests are not auto-registered by "fireforge register". ` +
             `Add "XPCSHELL_TESTS_MANIFESTS += ['${basename(filePath)}']" to the ` +
             `moz.build that covers ${filePath.replace(/\/xpcshell\.toml$/, '/')}, ` +
-            'or let `furnace create --test-style xpcshell` print the warning that names the canonical wiring location. ' +
+            'or register one of its test files with "fireforge register <path>/test_*.js --create-manifest", ' +
+            'which scaffolds the manifest and wires XPCSHELL_TESTS_MANIFESTS automatically. ' +
             'Browser-chrome tests (browser.toml) are auto-registered via "fireforge register <path>/browser.toml".');
     }
     const testMatch = filePath.match(/^browser\/base\/content\/test\/([^/]+)\/(?!browser\.toml$).+$/);
@@ -183,12 +208,17 @@ export async function isFileRegistered(root, filePath) {
     if (advice) {
         throw new InvalidArgumentError(advice, 'path');
     }
-    throw new InvalidArgumentError(`Unknown file pattern: "${normalizedPath}". Supported patterns:\n` +
+    throw new InvalidArgumentError(buildUnknownPatternMessage(normalizedPath, config.binaryName), 'path');
+}
+/** Shared "Unknown file pattern" message naming every supported pattern. */
+function buildUnknownPatternMessage(normalizedPath, binaryName) {
+    return (`Unknown file pattern: "${normalizedPath}". Supported patterns:\n` +
         '  browser/themes/shared/*.css\n' +
         '  browser/base/content/*.{js,mjs,xhtml,css}\n' +
-        '  browser/base/content/test/*/browser.toml\n' +
-        `  browser/modules/${config.binaryName}/*.sys.mjs\n` +
-        '  toolkit/content/widgets/*/*.{mjs,css}', 'path');
+        '  browser/base/content/test/**/browser.toml\n' +
+        `  browser/modules/${binaryName}/*.sys.mjs\n` +
+        '  toolkit/content/widgets/*/*.{mjs,css}\n' +
+        '  **/test_*.js (xpcshell test files; registers into the nearest xpcshell.toml)');
 }
 /**
  * Registers a file in the appropriate build manifest.
@@ -197,12 +227,14 @@ export async function isFileRegistered(root, filePath) {
  * @param filePath - Path relative to engine/
  * @param dryRun - If true, return what would be done without writing
  * @param after - Optional substring to place entry after (instead of alphabetical)
+ * @param options - `createManifest` scaffolds a missing manifest (directory
+ *   moz.build / xpcshell.toml) and wires the parent chain instead of failing
  * @returns Registration result
  */
-export async function registerFile(root, filePath, dryRun = false, after) {
+export async function registerFile(root, filePath, dryRun = false, after, options = {}) {
     const { engine: engineDir } = getProjectPaths(root);
     const config = await loadConfig(root);
-    const rules = getRules(config.binaryName);
+    const rules = getRules(config.binaryName, options.createManifest === true);
     // Normalize path separators
     const normalizedPath = filePath.replace(/\\/g, '/');
     for (const rule of rules) {
@@ -216,11 +248,6 @@ export async function registerFile(root, filePath, dryRun = false, after) {
     if (advice) {
         throw new InvalidArgumentError(advice, 'path');
     }
-    throw new InvalidArgumentError(`Unknown file pattern: "${normalizedPath}". Supported patterns:\n` +
-        '  browser/themes/shared/*.css\n' +
-        '  browser/base/content/*.{js,mjs,xhtml,css}\n' +
-        '  browser/base/content/test/*/browser.toml\n' +
-        `  browser/modules/${config.binaryName}/*.sys.mjs\n` +
-        '  toolkit/content/widgets/*/*.{mjs,css}', 'path');
+    throw new InvalidArgumentError(buildUnknownPatternMessage(normalizedPath, config.binaryName), 'path');
 }
 //# sourceMappingURL=manifest-rules.js.map

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

@@ -20,6 +20,16 @@ export declare function getNextPatchNumber(patchesDir: string): Promise<string>;
  * to a slug `export` could never reach.
  */
 export declare function sanitizeName(name: string): string;
+/**
+ * Strips a leading `NNN-<category>-` prefix from a sanitized name slug.
+ * Operators frequently pass the DESIRED FILENAME stem to `--name`
+ * (`--name 203-ui-foo --category ui`), which 0.33.0 double-prefixed into
+ * `203-ui-203-ui-foo.patch`. The filename builders prepend the order and
+ * category themselves, so a matching prefix in the name is always
+ * redundant. Applied repeatedly so a twice-prefixed slug (from a previous
+ * double-prefix incident) also collapses. Exported for direct testing.
+ */
+export declare function stripRedundantCategoryPrefix(sanitizedName: string, category: string): string;
 /**
  * Generates the next patch filename with category.
  * @param patchesDir - Path to the patches directory

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

@@ -46,6 +46,27 @@ export function sanitizeName(name) {
         .replace(/^-+|-+$/g, '')
         .slice(0, 50);
 }
+/**
+ * Strips a leading `NNN-<category>-` prefix from a sanitized name slug.
+ * Operators frequently pass the DESIRED FILENAME stem to `--name`
+ * (`--name 203-ui-foo --category ui`), which 0.33.0 double-prefixed into
+ * `203-ui-203-ui-foo.patch`. The filename builders prepend the order and
+ * category themselves, so a matching prefix in the name is always
+ * redundant. Applied repeatedly so a twice-prefixed slug (from a previous
+ * double-prefix incident) also collapses. Exported for direct testing.
+ */
+export function stripRedundantCategoryPrefix(sanitizedName, category) {
+    const prefix = new RegExp(`^\\d+-${category}-`);
+    let stripped = sanitizedName;
+    while (prefix.test(stripped)) {
+        stripped = stripped.replace(prefix, '');
+    }
+    return stripped.length > 0 ? stripped : sanitizedName;
+}
+/** Sanitizes a patch name and drops a redundant `NNN-<category>-` prefix. */
+function patchNameSlug(name, category) {
+    return stripRedundantCategoryPrefix(sanitizeName(name), category);
+}
 /**
  * Generates the next patch filename with category.
  * @param patchesDir - Path to the patches directory
@@ -55,7 +76,7 @@ export function sanitizeName(name) {
  */
 export async function getNextPatchFilename(patchesDir, category, name) {
     const patchNumber = await getNextPatchNumber(patchesDir);
-    const sanitizedName = sanitizeName(name);
+    const sanitizedName = patchNameSlug(name, category);
     return `${patchNumber}-${category}-${sanitizedName}.patch`;
 }
 /**
@@ -253,7 +274,7 @@ async function computeExportPlanUnderLock(input) {
         ? allocatePolicyOrder(input.config, manifestBefore?.patches ?? [], input.category)
         : null;
     const patchFilename = policyOrder !== null
-        ? `${String(policyOrder).padStart(3, '0')}-${input.category}-${sanitizeName(input.name)}.patch`
+        ? `${String(policyOrder).padStart(3, '0')}-${input.category}-${patchNameSlug(input.name, input.category)}.patch`
         : await getNextPatchFilename(input.patchesDir, input.category, input.name);
     const patchPath = join(input.patchesDir, patchFilename);
     const metadata = {

package/dist/src/core/register-module.d.ts

@@ -8,4 +8,4 @@ import type { RegisterResult } from './register-result.js';
  * Entry format:
  *     "{name}.sys.mjs",
  */
-export declare function registerFireForgeModule(engineDir: string, fileName: string, moduleDir: string, dryRun?: boolean): Promise<RegisterResult>;
+export declare function registerFireForgeModule(engineDir: string, fileName: string, moduleDir: string, dryRun?: boolean, createManifest?: boolean): Promise<RegisterResult>;

package/dist/src/core/register-module.js

@@ -8,6 +8,7 @@ import { pathExists, readText, writeText } from '../utils/fs.js';
 import { findAlphabeticalMozBuildPosition, findAlphabeticalPosition } from './manifest-helpers.js';
 import { tokenizeMozBuildList } from './manifest-tokenizers.js';
 import { withParserFallback } from './parser-fallback.js';
+import { scaffoldModuleMozBuild } from './register-scaffold.js';
 /**
  * Tokenizer-based implementation for module registration.
  */
@@ -55,11 +56,23 @@ function legacyRegisterFireForgeModule(content, fileName, entry, moduleDir) {
  * Entry format:
  *     "{name}.sys.mjs",
  */
-export async function registerFireForgeModule(engineDir, fileName, moduleDir, dryRun = false) {
+export async function registerFireForgeModule(engineDir, fileName, moduleDir, dryRun = false, createManifest = false) {
     const manifest = `${moduleDir}/moz.build`;
     const manifestPath = join(engineDir, manifest);
     if (!(await pathExists(manifestPath))) {
-        throw new GeneralError(`Manifest not found: ${manifest}`);
+        if (createManifest) {
+            // 0.34.0 field report: registering a module under a directory with
+            // no moz.build failed with "Manifest not found". Scaffold the
+            // directory manifest and wire the parent DIRS chain.
+            const scaffoldActions = await scaffoldModuleMozBuild(engineDir, moduleDir, fileName, dryRun);
+            return {
+                manifest,
+                entry: `    "${fileName}",`,
+                skipped: false,
+                scaffoldActions,
+            };
+        }
+        throw new GeneralError(`Manifest not found: ${manifest}. Pass --create-manifest to scaffold it and wire the parent DIRS entry.`);
     }
     const entry = `    "${fileName}",`.replace(/\\/g, '/');
     const content = await readText(manifestPath);

package/dist/src/core/register-result.d.ts

@@ -18,4 +18,13 @@ export interface RegisterResult {
     skipped: boolean;
     /** Whether --after target was not found and fell back to alphabetical */
     afterFallback?: boolean | undefined;
+    /**
+     * Manifests created or wired by `--create-manifest` scaffolding
+     * (directory moz.build, parent DIRS chain, XPCSHELL_TESTS_MANIFESTS),
+     * for user display.
+     */
+    scaffoldActions?: {
+        manifest: string;
+        change: string;
+    }[] | undefined;
 }

package/dist/src/core/register-scaffold.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Manifest scaffolding for `fireforge register --create-manifest`
+ * (0.34.0 field report): registering a module under a directory with no
+ * moz.build used to fail with "Manifest not found" because `register`
+ * only inserts into EXISTING manifests. This module owns the two
+ * scaffolding primitives:
+ *
+ *  - creating a directory `moz.build` (license header + the requested
+ *    list directive) and wiring the parent chain's `DIRS` entries up to
+ *    the nearest existing moz.build;
+ *  - wiring an `XPCSHELL_TESTS_MANIFESTS` entry for a (possibly freshly
+ *    created) `xpcshell.toml` into the nearest existing moz.build.
+ *
+ * All writers reuse the tokenizer + alphabetical-position helpers the
+ * existing register writers use, so inserted entries respect mozbuild's
+ * case-insensitive StrictOrderingOnAppendList rule.
+ */
+/** One manifest mutation performed (or planned, on dry-run) by a scaffold. */
+export interface ScaffoldAction {
+    /** Engine-relative manifest path that was created or modified. */
+    manifest: string;
+    /** Human-readable description of the change. */
+    change: string;
+}
+/**
+ * Inserts `value` into the named moz.build list directive, creating the
+ * `NAME += [ ... ]` block at the end of the file when the directive does
+ * not exist yet. Returns the updated content, or null when the value is
+ * already present.
+ */
+export declare function upsertMozBuildListEntry(content: string, directive: string, value: string): string | null;
+/**
+ * Ensures every parent directory between `childRelDir` and the nearest
+ * existing moz.build carries a `DIRS` entry pointing at the next segment
+ * down, creating intermediate moz.build files as needed. Walks upward
+ * from the child's parent; throws when no moz.build exists anywhere up
+ * to the engine root (an engine checkout always has one at the root, so
+ * this indicates a bogus path).
+ */
+export declare function ensureParentDirsWiring(engineDir: string, childRelDir: string, dryRun: boolean): Promise<ScaffoldAction[]>;
+/**
+ * Creates `<moduleDir>/moz.build` with an `EXTRA_JS_MODULES.<namespace>`
+ * list containing `fileName`, and wires the parent DIRS chain. The
+ * namespace is the module directory's basename (the fork's binary name
+ * for `browser/modules/<binaryName>/`), matching Firefox's convention of
+ * mapping `EXTRA_JS_MODULES.<ns>` into `resource:///modules/<ns>/`.
+ */
+export declare function scaffoldModuleMozBuild(engineDir: string, moduleDir: string, fileName: string, dryRun: boolean): Promise<ScaffoldAction[]>;
+/**
+ * Wires an `XPCSHELL_TESTS_MANIFESTS` entry for `manifestRelPath` (an
+ * engine-relative `.../xpcshell.toml`) into the nearest EXISTING
+ * moz.build above it. Returns the performed actions (empty when the
+ * entry already exists).
+ */
+export declare function ensureXpcshellManifestWiring(engineDir: string, manifestRelPath: string, dryRun: boolean): Promise<ScaffoldAction[]>;

package/dist/src/core/register-scaffold.js

@@ -0,0 +1,146 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Manifest scaffolding for `fireforge register --create-manifest`
+ * (0.34.0 field report): registering a module under a directory with no
+ * moz.build used to fail with "Manifest not found" because `register`
+ * only inserts into EXISTING manifests. This module owns the two
+ * scaffolding primitives:
+ *
+ *  - creating a directory `moz.build` (license header + the requested
+ *    list directive) and wiring the parent chain's `DIRS` entries up to
+ *    the nearest existing moz.build;
+ *  - wiring an `XPCSHELL_TESTS_MANIFESTS` entry for a (possibly freshly
+ *    created) `xpcshell.toml` into the nearest existing moz.build.
+ *
+ * All writers reuse the tokenizer + alphabetical-position helpers the
+ * existing register writers use, so inserted entries respect mozbuild's
+ * case-insensitive StrictOrderingOnAppendList rule.
+ */
+import { dirname, join } from 'node:path';
+import { GeneralError } from '../errors/base.js';
+import { pathExists, readText, writeText } from '../utils/fs.js';
+import { getLicenseHeader } from './license-headers.js';
+import { findAlphabeticalMozBuildPosition } from './manifest-helpers.js';
+import { tokenizeMozBuildList } from './manifest-tokenizers.js';
+/**
+ * moz.build files use Firefox's canonical MPL-2.0 hash-comment header
+ * regardless of the fork's own project license — they live in the engine
+ * tree among upstream MPL files.
+ */
+function mozBuildHeader() {
+    return getLicenseHeader('MPL-2.0', 'hash');
+}
+/**
+ * Inserts `value` into the named moz.build list directive, creating the
+ * `NAME += [ ... ]` block at the end of the file when the directive does
+ * not exist yet. Returns the updated content, or null when the value is
+ * already present.
+ */
+export function upsertMozBuildListEntry(content, directive, value) {
+    if (content.includes(`"${value}"`))
+        return null;
+    const lines = content.split('\n');
+    const listResult = tokenizeMozBuildList(lines, new RegExp(`^${directive}\\b`));
+    if (listResult) {
+        const { insertIndex } = findAlphabeticalMozBuildPosition(listResult.tokens, value);
+        lines.splice(insertIndex, 0, `    "${value}",`);
+        return lines.join('\n');
+    }
+    // No existing list: append a fresh block, keeping exactly one blank
+    // line between the previous content and the new directive.
+    while (lines.length > 0 && (lines.at(-1) ?? '').trim() === '')
+        lines.pop();
+    const block = [`${directive} += [`, `    "${value}",`, `]`];
+    return [...lines, ...(lines.length > 0 ? [''] : []), ...block, ''].join('\n');
+}
+/**
+ * Ensures every parent directory between `childRelDir` and the nearest
+ * existing moz.build carries a `DIRS` entry pointing at the next segment
+ * down, creating intermediate moz.build files as needed. Walks upward
+ * from the child's parent; throws when no moz.build exists anywhere up
+ * to the engine root (an engine checkout always has one at the root, so
+ * this indicates a bogus path).
+ */
+export async function ensureParentDirsWiring(engineDir, childRelDir, dryRun) {
+    const actions = [];
+    let childName = childRelDir.split('/').at(-1) ?? childRelDir;
+    let parentRel = dirname(childRelDir).replace(/\\/g, '/');
+    for (;;) {
+        if (parentRel === '.' || parentRel === '' || parentRel === '/') {
+            throw new GeneralError(`No moz.build found in any parent of ${childRelDir} up to the engine root; ` +
+                'cannot wire the DIRS chain. Check the path.');
+        }
+        const parentManifestRel = `${parentRel}/moz.build`;
+        const parentManifestPath = join(engineDir, parentManifestRel);
+        if (await pathExists(parentManifestPath)) {
+            const content = await readText(parentManifestPath);
+            const updated = upsertMozBuildListEntry(content, 'DIRS', childName);
+            if (updated !== null) {
+                if (!dryRun)
+                    await writeText(parentManifestPath, updated);
+                actions.push({ manifest: parentManifestRel, change: `DIRS += ["${childName}"]` });
+            }
+            return actions;
+        }
+        // Parent has no moz.build either: scaffold one carrying the DIRS
+        // entry and keep walking up until an existing manifest anchors the
+        // chain.
+        const scaffold = `${mozBuildHeader()}\n\nDIRS += [\n    "${childName}",\n]\n`;
+        if (!dryRun)
+            await writeText(parentManifestPath, scaffold);
+        actions.push({ manifest: parentManifestRel, change: `created with DIRS += ["${childName}"]` });
+        childName = parentRel.split('/').at(-1) ?? parentRel;
+        parentRel = dirname(parentRel).replace(/\\/g, '/');
+    }
+}
+/**
+ * Creates `<moduleDir>/moz.build` with an `EXTRA_JS_MODULES.<namespace>`
+ * list containing `fileName`, and wires the parent DIRS chain. The
+ * namespace is the module directory's basename (the fork's binary name
+ * for `browser/modules/<binaryName>/`), matching Firefox's convention of
+ * mapping `EXTRA_JS_MODULES.<ns>` into `resource:///modules/<ns>/`.
+ */
+export async function scaffoldModuleMozBuild(engineDir, moduleDir, fileName, dryRun) {
+    const namespace = moduleDir.split('/').at(-1) ?? moduleDir;
+    const manifestRel = `${moduleDir}/moz.build`;
+    const content = `${mozBuildHeader()}\n\nEXTRA_JS_MODULES.${namespace} += [\n    "${fileName}",\n]\n`;
+    if (!dryRun)
+        await writeText(join(engineDir, manifestRel), content);
+    const actions = [
+        {
+            manifest: manifestRel,
+            change: `created with EXTRA_JS_MODULES.${namespace} += ["${fileName}"]`,
+        },
+    ];
+    actions.push(...(await ensureParentDirsWiring(engineDir, moduleDir, dryRun)));
+    return actions;
+}
+/**
+ * Wires an `XPCSHELL_TESTS_MANIFESTS` entry for `manifestRelPath` (an
+ * engine-relative `.../xpcshell.toml`) into the nearest EXISTING
+ * moz.build above it. Returns the performed actions (empty when the
+ * entry already exists).
+ */
+export async function ensureXpcshellManifestWiring(engineDir, manifestRelPath, dryRun) {
+    let dirRel = dirname(manifestRelPath).replace(/\\/g, '/');
+    for (;;) {
+        if (dirRel === '.' || dirRel === '' || dirRel === '/') {
+            throw new GeneralError(`No moz.build found in any parent of ${manifestRelPath} up to the engine root; ` +
+                'cannot wire XPCSHELL_TESTS_MANIFESTS. Check the path.');
+        }
+        const mozBuildRel = `${dirRel}/moz.build`;
+        const mozBuildPath = join(engineDir, mozBuildRel);
+        if (await pathExists(mozBuildPath)) {
+            const relEntry = manifestRelPath.slice(dirRel.length + 1);
+            const content = await readText(mozBuildPath);
+            const updated = upsertMozBuildListEntry(content, 'XPCSHELL_TESTS_MANIFESTS', relEntry);
+            if (updated === null)
+                return [];
+            if (!dryRun)
+                await writeText(mozBuildPath, updated);
+            return [{ manifest: mozBuildRel, change: `XPCSHELL_TESTS_MANIFESTS += ["${relEntry}"]` }];
+        }
+        dirRel = dirname(dirRel).replace(/\\/g, '/');
+    }
+}
+//# sourceMappingURL=register-scaffold.js.map

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

@@ -27,7 +27,9 @@ function registerTestManifestTokenized(content, testDir, entry) {
 function legacyRegisterTestManifest(content, testDir, entry) {
     const lines = content.split('\n');
     const extractKey = (line) => {
-        const match = /"content\/test\/([^/]+)\/browser\.toml"/.exec(line);
+        // Nested manifests (`content/test/a/b/browser.toml`) are supported —
+        // capture the whole directory chain, not just one segment.
+        const match = /"content\/test\/(.+)\/browser\.toml"/.exec(line);
         return match?.[1];
     };
     let sectionStart = -1;

package/dist/src/core/register-xpcshell-test.d.ts

@@ -0,0 +1,30 @@
+/**
+ * xpcshell test-file registration (0.34.0 field report): xpcshell test
+ * files (e.g. `<module-dir>/test/unit/test_*.js`) were rejected by
+ * `fireforge register` as "Unknown file pattern". This writer inserts the
+ * `["test_*.js"]` section into the directory's `xpcshell.toml`
+ * (alphabetically, idempotently) and — with `--create-manifest` — creates
+ * the manifest and wires `XPCSHELL_TESTS_MANIFESTS` into the nearest
+ * moz.build.
+ */
+import type { RegisterResult } from './register-result.js';
+/**
+ * Checks whether the test file is listed in its directory's
+ * `xpcshell.toml`. Throws a "Manifest not found" error when the manifest
+ * does not exist (status catches that prefix and reports the manifest as
+ * missing rather than the file as unregistered).
+ */
+export declare function isXpcshellTestRegistered(engineDir: string, dirRel: string, fileName: string): Promise<boolean>;
+/**
+ * Inserts the `["<fileName>"]` section into the manifest content in
+ * mozbuild's case-insensitive sort order relative to the other test
+ * sections, keeping one blank line between sections. Exported for direct
+ * unit testing.
+ */
+export declare function insertXpcshellManifestSection(content: string, fileName: string): string;
+/**
+ * Registers an xpcshell test file in its directory's `xpcshell.toml`.
+ * With `createManifest`, a missing manifest is scaffolded and wired into
+ * the nearest moz.build via `XPCSHELL_TESTS_MANIFESTS`.
+ */
+export declare function registerXpcshellTest(engineDir: string, dirRel: string, fileName: string, dryRun?: boolean, createManifest?: boolean): Promise<RegisterResult>;

package/dist/src/core/register-xpcshell-test.js

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * xpcshell test-file registration (0.34.0 field report): xpcshell test
+ * files (e.g. `<module-dir>/test/unit/test_*.js`) were rejected by
+ * `fireforge register` as "Unknown file pattern". This writer inserts the
+ * `["test_*.js"]` section into the directory's `xpcshell.toml`
+ * (alphabetically, idempotently) and — with `--create-manifest` — creates
+ * the manifest and wires `XPCSHELL_TESTS_MANIFESTS` into the nearest
+ * moz.build.
+ */
+import { join } from 'node:path';
+import { GeneralError } from '../errors/base.js';
+import { pathExists, readText, writeText } from '../utils/fs.js';
+import { mozbuildSortCompare } from './manifest-helpers.js';
+import { ensureXpcshellManifestWiring } from './register-scaffold.js';
+function manifestMissingError(manifestRel) {
+    return new GeneralError(`Manifest not found: ${manifestRel}. ` +
+        'Pass --create-manifest to scaffold the xpcshell.toml and wire XPCSHELL_TESTS_MANIFESTS ' +
+        'into the nearest moz.build.');
+}
+/**
+ * Checks whether the test file is listed in its directory's
+ * `xpcshell.toml`. Throws a "Manifest not found" error when the manifest
+ * does not exist (status catches that prefix and reports the manifest as
+ * missing rather than the file as unregistered).
+ */
+export async function isXpcshellTestRegistered(engineDir, dirRel, fileName) {
+    const manifestRel = `${dirRel}/xpcshell.toml`;
+    const manifestPath = join(engineDir, manifestRel);
+    if (!(await pathExists(manifestPath))) {
+        throw manifestMissingError(manifestRel);
+    }
+    const content = await readText(manifestPath);
+    return content.includes(`["${fileName}"]`);
+}
+/**
+ * Inserts the `["<fileName>"]` section into the manifest content in
+ * mozbuild's case-insensitive sort order relative to the other test
+ * sections, keeping one blank line between sections. Exported for direct
+ * unit testing.
+ */
+export function insertXpcshellManifestSection(content, fileName) {
+    const lines = content.split('\n');
+    const sectionHeaderPattern = /^\["([^"]+)"\]\s*$/;
+    let insertIndex = -1;
+    for (let i = 0; i < lines.length; i += 1) {
+        const match = sectionHeaderPattern.exec(lines[i] ?? '');
+        if (!match)
+            continue;
+        if (insertIndex === -1 && mozbuildSortCompare(fileName, match[1] ?? '') < 0) {
+            insertIndex = i;
+        }
+    }
+    if (insertIndex !== -1) {
+        lines.splice(insertIndex, 0, `["${fileName}"]`, '');
+        return lines.join('\n');
+    }
+    // Append after the last section (or at end of file when there are no
+    // sections yet), keeping exactly one trailing newline.
+    while (lines.length > 0 && (lines.at(-1) ?? '').trim() === '')
+        lines.pop();
+    return [...lines, '', `["${fileName}"]`, ''].join('\n');
+}
+/**
+ * Registers an xpcshell test file in its directory's `xpcshell.toml`.
+ * With `createManifest`, a missing manifest is scaffolded and wired into
+ * the nearest moz.build via `XPCSHELL_TESTS_MANIFESTS`.
+ */
+export async function registerXpcshellTest(engineDir, dirRel, fileName, dryRun = false, createManifest = false) {
+    const manifestRel = `${dirRel}/xpcshell.toml`;
+    const manifestPath = join(engineDir, manifestRel);
+    const entry = `["${fileName}"]`;
+    if (!(await pathExists(manifestPath))) {
+        if (!createManifest) {
+            throw manifestMissingError(manifestRel);
+        }
+        const scaffoldActions = [
+            { manifest: manifestRel, change: `created with ${entry}` },
+        ];
+        if (!dryRun) {
+            await writeText(manifestPath, `[DEFAULT]\n\n${entry}\n`);
+        }
+        scaffoldActions.push(...(await ensureXpcshellManifestWiring(engineDir, manifestRel, dryRun)));
+        return { manifest: manifestRel, entry, skipped: false, scaffoldActions };
+    }
+    const content = await readText(manifestPath);
+    if (content.includes(entry)) {
+        return { manifest: manifestRel, entry, skipped: true };
+    }
+    const updated = insertXpcshellManifestSection(content, fileName);
+    if (!dryRun) {
+        await writeText(manifestPath, updated);
+    }
+    return { manifest: manifestRel, entry, skipped: false };
+}
+//# sourceMappingURL=register-xpcshell-test.js.map