@hominis/fireforge 0.32.0 → 0.34.0

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/patch-lint-cross.d.ts

@@ -180,6 +180,37 @@ export declare function findForwardImportIgnoreLines(source: string): Set<number
  *   engine file — not our concern).
  * - Imports on a line suppressed by the ignore marker.
  */
+/** One discovered forward-import edge: a site importing a later-created file. */
+export interface ForwardImportEdge {
+    /** Importing patch filename. */
+    entry: string;
+    /** Importing file path relative to engine/. */
+    sitePath: string;
+    /** Exact import specifier as it appears in source. */
+    specifier: string;
+    /** Specifier with any query/hash stripped (used for fingerprints). */
+    cleaned: string;
+    /** Later-ordered patch creating the imported file. */
+    owner: string;
+    /** Path of the later-created file (relative to engine/). */
+    creates: string;
+}
+/**
+ * Returns every forward-import edge in the queue, one per (site, later
+ * creator) pair, regardless of any staged-dependency declarations. Used by
+ * `patch split` to discover the forward edges it introduces into the new
+ * patch so it can auto-declare them (and so its projected lint matches the
+ * real per-patch gate).
+ */
+export declare function collectForwardImportEdges(ctx: PatchQueueContext): ForwardImportEdge[];
+/**
+ * Cross-patch lint rule: flag imports of a module a later-ordered patch is
+ * responsible for creating, unless the patch declares an exact staged
+ * forward-import for it. Also warns on staged-dependency declarations that
+ * never matched (stale). Matching is conservative — by basename, not by
+ * resolving `resource://`/`chrome://` URLs — with an inline ignore marker as
+ * an escape hatch for unrelated basename collisions.
+ */
 export declare function lintPatchQueueForwardImports(ctx: PatchQueueContext): PatchLintIssue[];
 /**
  * Cross-patch lint orchestrator. Runs every cross-patch rule against the

package/dist/src/core/patch-lint-cross.js

@@ -343,27 +343,8 @@ function findMatchingStagedDependency(entry, sitePath, specifier, laterOwners) {
         laterOwners.some((owner) => owner.fullPath === dependency.creates &&
             (dependency.owner === undefined || dependency.owner === owner.filename)));
 }
-/**
- * Cross-patch lint rule: a patch imports a module that a later patch is
- * responsible for creating.
- *
- * Approach is deliberately conservative — we do not resolve `resource://`
- * URLs to engine file paths. Instead we build a cross-queue index of
- * newly-created files keyed by their basename, and flag imports whose leaf
- * matches an entry owned by a later-ordered patch. False positives from
- * unrelated basename collisions (two different directories happening to
- * create files named `Helper.sys.mjs`) are possible; the README documents
- * the limitation and the inline ignore marker above provides an escape
- * hatch.
- *
- * Rules out:
- * - Imports whose leaf matches a newly-created file in the *same* or an
- *   *earlier* patch (legitimate use).
- * - Imports whose leaf is not in the new-file index at all (pre-existing
- *   engine file — not our concern).
- * - Imports on a line suppressed by the ignore marker.
- */
-export function lintPatchQueueForwardImports(ctx) {
+/** Builds the basename → later-creators index used by the forward-import scan. */
+function buildNewFileIndex(ctx) {
     const newFileIndex = new Map();
     for (const entry of ctx.entries) {
         for (const fullPath of entry.newFiles.keys()) {
@@ -376,23 +357,24 @@ export function lintPatchQueueForwardImports(ctx) {
             owners.push({ filename: entry.filename, order: entry.order, fullPath });
         }
     }
-    const issues = [];
-    const usedStagedDeclarations = new Set();
-    // Runs the forward-import check against one source site — either a file
-    // the patch creates (`content` = full file) or a file the patch modifies
-    // (`content` = concatenated added lines only). We deliberately scan added
-    // lines rather than the full resulting file for modifications: we only
-    // want to flag imports *this patch introduces*, not imports that already
-    // exist on HEAD and happen to match a later-created file by coincidence.
+    return newFileIndex;
+}
+/**
+ * Visits every forward-import site (an import whose leaf is created by a
+ * later-ordered patch). Shared by {@link lintPatchQueueForwardImports} (which
+ * resolves/reports each) and {@link collectForwardImportEdges} (which returns
+ * them structurally). We scan a created file's full body and a modified
+ * file's added lines only — flagging imports *this patch introduces*, not
+ * pre-existing HEAD imports that happen to collide with a later-created file.
+ */
+function eachForwardImportSite(ctx, newFileIndex, visit) {
     const checkSite = (entry, sitePath, content) => {
         if (!isForwardImportableFile(sitePath))
             return;
         const ignoreLines = findForwardImportIgnoreLines(content);
-        const extracted = extractImportSpecifiersWithLines(content);
-        for (const { specifier, line } of extracted) {
+        for (const { specifier, line } of extractImportSpecifiersWithLines(content)) {
             if (ignoreLines.has(line))
                 continue;
-            // Take the leaf and strip query/hash if any.
             const cleaned = specifier.split(/[?#]/)[0] ?? specifier;
             const leaf = basename(cleaned);
             if (!leaf || !isForwardImportableFile(leaf))
@@ -400,41 +382,11 @@ export function lintPatchQueueForwardImports(ctx) {
             const owners = newFileIndex.get(leaf);
             if (!owners)
                 continue;
-            // Is the owner a later-ordered patch (or one ordered equal but
-            // lexicographically later as a tiebreaker)?
             const laterOwners = owners.filter((owner) => owner.order > entry.order ||
                 (owner.order === entry.order && owner.filename > entry.filename));
             if (laterOwners.length === 0)
                 continue;
-            const stagedDependency = findMatchingStagedDependency(entry, sitePath, specifier, laterOwners);
-            if (stagedDependency) {
-                usedStagedDeclarations.add(stagedDependencyKey(entry, stagedDependency));
-                continue;
-            }
-            const ownersSummary = laterOwners
-                .map((o) => `${o.filename} (creates ${o.fullPath})`)
-                .join(', ');
-            const fingerprintOwners = [...laterOwners]
-                .map((o) => `${o.filename}:${o.fullPath}`)
-                .sort((a, b) => a.localeCompare(b))
-                .join(',');
-            // Lowest ordinal that lands AFTER every later-ordered creator —
-            // turns the operator's "guess and re-run" loop into a single shot
-            // when the only fix is reordering.
-            const suggestedOrder = Math.max(...laterOwners.map((o) => o.order)) + 1;
-            issues.push({
-                file: sitePath,
-                check: 'forward-import',
-                fingerprint: `forward-import|${sitePath}|${cleaned}|${fingerprintOwners}`,
-                message: `${sitePath} in ${entry.filename} imports "${specifier}", ` +
-                    `but the matching new file is created by a later patch: ${ownersSummary}. ` +
-                    'Reorder the patches so the dependency is created first, move the import ' +
-                    'into the later patch, declare the intentional staged dependency with ' +
-                    '"fireforge patch staged-dependency --add", or mark the import with ' +
-                    `"// ${FORWARD_IMPORT_IGNORE_MARKER}" if the basename collision is a false positive. ` +
-                    `Closest legal ordinal that satisfies this dependency: ${suggestedOrder}.`,
-                severity: 'error',
-            });
+            visit(entry, sitePath, specifier, cleaned, laterOwners);
         }
     };
     for (const entry of ctx.entries) {
@@ -443,6 +395,74 @@ export function lintPatchQueueForwardImports(ctx) {
         for (const [path, added] of entry.modifiedFileAdditions)
             checkSite(entry, path, added);
     }
+}
+/**
+ * Returns every forward-import edge in the queue, one per (site, later
+ * creator) pair, regardless of any staged-dependency declarations. Used by
+ * `patch split` to discover the forward edges it introduces into the new
+ * patch so it can auto-declare them (and so its projected lint matches the
+ * real per-patch gate).
+ */
+export function collectForwardImportEdges(ctx) {
+    const newFileIndex = buildNewFileIndex(ctx);
+    const edges = [];
+    eachForwardImportSite(ctx, newFileIndex, (entry, sitePath, specifier, cleaned, laterOwners) => {
+        for (const owner of laterOwners) {
+            edges.push({
+                entry: entry.filename,
+                sitePath,
+                specifier,
+                cleaned,
+                owner: owner.filename,
+                creates: owner.fullPath,
+            });
+        }
+    });
+    return edges;
+}
+/**
+ * Cross-patch lint rule: flag imports of a module a later-ordered patch is
+ * responsible for creating, unless the patch declares an exact staged
+ * forward-import for it. Also warns on staged-dependency declarations that
+ * never matched (stale). Matching is conservative — by basename, not by
+ * resolving `resource://`/`chrome://` URLs — with an inline ignore marker as
+ * an escape hatch for unrelated basename collisions.
+ */
+export function lintPatchQueueForwardImports(ctx) {
+    const newFileIndex = buildNewFileIndex(ctx);
+    const issues = [];
+    const usedStagedDeclarations = new Set();
+    eachForwardImportSite(ctx, newFileIndex, (entry, sitePath, specifier, cleaned, laterOwners) => {
+        const stagedDependency = findMatchingStagedDependency(entry, sitePath, specifier, laterOwners);
+        if (stagedDependency) {
+            usedStagedDeclarations.add(stagedDependencyKey(entry, stagedDependency));
+            return;
+        }
+        const ownersSummary = laterOwners
+            .map((o) => `${o.filename} (creates ${o.fullPath})`)
+            .join(', ');
+        const fingerprintOwners = [...laterOwners]
+            .map((o) => `${o.filename}:${o.fullPath}`)
+            .sort((a, b) => a.localeCompare(b))
+            .join(',');
+        // Lowest ordinal that lands AFTER every later-ordered creator —
+        // turns the operator's "guess and re-run" loop into a single shot
+        // when the only fix is reordering.
+        const suggestedOrder = Math.max(...laterOwners.map((o) => o.order)) + 1;
+        issues.push({
+            file: sitePath,
+            check: 'forward-import',
+            fingerprint: `forward-import|${sitePath}|${cleaned}|${fingerprintOwners}`,
+            message: `${sitePath} in ${entry.filename} imports "${specifier}", ` +
+                `but the matching new file is created by a later patch: ${ownersSummary}. ` +
+                'Reorder the patches so the dependency is created first, move the import ' +
+                'into the later patch, declare the intentional staged dependency with ' +
+                '"fireforge patch staged-dependency --add", or mark the import with ' +
+                `"// ${FORWARD_IMPORT_IGNORE_MARKER}" if the basename collision is a false positive. ` +
+                `Closest legal ordinal that satisfies this dependency: ${suggestedOrder}.`,
+            severity: 'error',
+        });
+    });
     for (const entry of ctx.entries) {
         for (const dependency of entry.metadata?.stagedDependencies?.forwardImports ?? []) {
             if (usedStagedDeclarations.has(stagedDependencyKey(entry, dependency)))

package/dist/src/core/patch-lint-reexports.d.ts

@@ -2,5 +2,5 @@
  * Public re-exports for {@link ./patch-lint.ts}. Split out so the
  * orchestrator stays within the ESLint `max-lines` budget.
  */
-export { buildPatchQueueContext, collectNewFileCreatorsByPath, extractImportSpecifiers, extractImportSpecifiersWithLines, findForwardImportIgnoreLines, FORWARD_IMPORT_IGNORE_MARKER, isForwardImportableFile, lintPatchQueue, lintPatchQueueDuplicateCreations, lintPatchQueueForwardImports, type PatchQueueContext, type PatchQueueEntry, } from './patch-lint-cross.js';
+export { buildPatchQueueContext, collectForwardImportEdges, collectNewFileCreatorsByPath, extractImportSpecifiers, extractImportSpecifiersWithLines, findForwardImportIgnoreLines, FORWARD_IMPORT_IGNORE_MARKER, type ForwardImportEdge, isForwardImportableFile, lintPatchQueue, lintPatchQueueDuplicateCreations, lintPatchQueueForwardImports, type PatchQueueContext, type PatchQueueEntry, } from './patch-lint-cross.js';
 export { buildModifiedFileAdditionsFromDiff, detectNewFilesInDiff } from './patch-lint-diff.js';

package/dist/src/core/patch-lint-reexports.js

@@ -3,6 +3,6 @@
  * Public re-exports for {@link ./patch-lint.ts}. Split out so the
  * orchestrator stays within the ESLint `max-lines` budget.
  */
-export { buildPatchQueueContext, collectNewFileCreatorsByPath, extractImportSpecifiers, extractImportSpecifiersWithLines, findForwardImportIgnoreLines, FORWARD_IMPORT_IGNORE_MARKER, isForwardImportableFile, lintPatchQueue, lintPatchQueueDuplicateCreations, lintPatchQueueForwardImports, } from './patch-lint-cross.js';
+export { buildPatchQueueContext, collectForwardImportEdges, collectNewFileCreatorsByPath, extractImportSpecifiers, extractImportSpecifiersWithLines, findForwardImportIgnoreLines, FORWARD_IMPORT_IGNORE_MARKER, isForwardImportableFile, lintPatchQueue, lintPatchQueueDuplicateCreations, lintPatchQueueForwardImports, } from './patch-lint-cross.js';
 export { buildModifiedFileAdditionsFromDiff, detectNewFilesInDiff } from './patch-lint-diff.js';
 //# sourceMappingURL=patch-lint-reexports.js.map

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[]>;