@hominis/fireforge 0.15.8 → 0.16.0

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

@@ -16,7 +16,15 @@ export function getRules(binaryName) {
             extractArgs: (m) => [m[1] ?? ''],
         },
         {
-            pattern: /^browser\/base\/content\/(.+\.(?:js|mjs|xhtml|css))$/,
+            // `.inc.xhtml` fragments under browser/base/content/ are deliberately
+            // excluded: they are consumed via `#include` from a registered chrome
+            // document (typically browser.xhtml) and do not get their own
+            // packaged chrome URI. Before this carve-out, `status` flagged every
+            // wired fragment as "potentially unregistered" and `register --dry-run`
+            // proposed a bogus jar.mn entry. The lookahead blocks the match so
+            // `getUnregistrableAdvice` gets a chance to emit the correct
+            // guidance for the `.inc.xhtml` case.
+            pattern: /^browser\/base\/content\/(?!.+\.inc\.xhtml$)(.+\.(?:js|mjs|xhtml|css))$/,
             isRegistered: (engineDir, fileName) => isBrowserContentRegistered(engineDir, fileName),
             register: (engineDir, after, dryRun, fileName) => registerBrowserContent(engineDir, fileName, after, undefined, dryRun),
             extractArgs: (m) => [m[1] ?? ''],
@@ -98,6 +106,19 @@ function getUnregistrableAdvice(filePath) {
     if (filePath.endsWith('.ftl')) {
         return "FTL locale files are auto-discovered via jar.mn glob patterns and don't need manual registration.";
     }
+    // `.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
+    // 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
+    // "unknown file pattern" message above fire.
+    if (/^browser\/base\/content\/.+\.inc\.xhtml$/.test(filePath)) {
+        return ('`.inc.xhtml` fragments are consumed via `#include` from a registered chrome document ' +
+            '(e.g. browser.xhtml). They do not need an independent jar.mn entry — run ' +
+            '"fireforge wire <name> --dom <path>" to insert the #include, or add the directive manually ' +
+            'in the top-level chrome document.');
+    }
     const testMatch = filePath.match(/^browser\/base\/content\/test\/([^/]+)\/(?!browser\.toml$).+$/);
     if (testMatch) {
         const dir = testMatch[1];

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

@@ -89,6 +89,11 @@ export declare function lintModifiedFileHeaders(repoDir: string, affectedFiles:
  * @param diffContent - Raw unified diff string
  * @param config - Project configuration
  * @param patchQueueCtx - Optional cross-patch context for ownership resolution
+ * @param ignoreChecks - Optional set of per-patch `check` IDs to drop from the
+ *   returned issues. Threaded from `PatchMetadata.lintIgnore` so a patch that
+ *   is advisory-noisy by nature (a cohesive branding bundle, auto-generated
+ *   manifest, etc.) can opt out of a specific rule without reaching for the
+ *   blunt `--skip-lint` hammer. Not mutated by this function.
  * @returns Array of all lint issues found
  */
-export declare function lintExportedPatch(repoDir: string, affectedFiles: string[], diffContent: string, config: FireForgeConfig, patchQueueCtx?: import('./patch-lint-cross.js').PatchQueueContext): Promise<PatchLintIssue[]>;
+export declare function lintExportedPatch(repoDir: string, affectedFiles: string[], diffContent: string, config: FireForgeConfig, patchQueueCtx?: import('./patch-lint-cross.js').PatchQueueContext, ignoreChecks?: ReadonlySet<string>): Promise<PatchLintIssue[]>;

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

@@ -455,9 +455,14 @@ export async function lintModifiedFileHeaders(repoDir, affectedFiles, newFiles)
  * @param diffContent - Raw unified diff string
  * @param config - Project configuration
  * @param patchQueueCtx - Optional cross-patch context for ownership resolution
+ * @param ignoreChecks - Optional set of per-patch `check` IDs to drop from the
+ *   returned issues. Threaded from `PatchMetadata.lintIgnore` so a patch that
+ *   is advisory-noisy by nature (a cohesive branding bundle, auto-generated
+ *   manifest, etc.) can opt out of a specific rule without reaching for the
+ *   blunt `--skip-lint` hammer. Not mutated by this function.
  * @returns Array of all lint issues found
  */
-export async function lintExportedPatch(repoDir, affectedFiles, diffContent, config, patchQueueCtx) {
+export async function lintExportedPatch(repoDir, affectedFiles, diffContent, config, patchQueueCtx, ignoreChecks) {
     const newFiles = detectNewFilesInDiff(diffContent);
     const { textLines: lineCount } = countNonBinaryDiffLines(diffContent);
     const patchOwnedFiles = resolvePatchOwnedSysMjs(newFiles, patchQueueCtx);
@@ -482,6 +487,14 @@ export async function lintExportedPatch(repoDir, affectedFiles, diffContent, con
         const checkJsIssues = await runCheckJs(repoDir, patchOwnedFiles);
         issues.push(...checkJsIssues);
     }
+    // Filter out ignored checks last so every rule still runs (keeps the
+    // implementation uniform) but suppressed rules do not surface. We do not
+    // reclassify severities — an ignored error simply drops, mirroring how
+    // inline `fireforge-ignore: <check>` markers work in the CSS and
+    // forward-import rules.
+    if (ignoreChecks && ignoreChecks.size > 0) {
+        return issues.filter((issue) => !ignoreChecks.has(issue.check));
+    }
     return issues;
 }
 //# sourceMappingURL=patch-lint.js.map

package/dist/src/types/commands/options.d.ts

@@ -155,6 +155,16 @@ export interface ReExportOptions {
     yes?: boolean;
     /** Bypass cross-patch lint refusal on projected shrink state */
     forceUnsafe?: boolean;
+    /**
+     * After every selected patch re-exports cleanly, stamp each re-exported
+     * patch's `sourceEsrVersion` in `patches.json` to the current
+     * `firefox.version` from `fireforge.json`. Opt-in because the default
+     * contract of `re-export` is "refresh the patch body and filesAffected";
+     * version stamping is normally a `rebase` responsibility. Use this when
+     * re-exporting after a manual Firefox bump that did not go through
+     * `rebase`.
+     */
+    stamp?: boolean;
 }
 /**
  * Options for the rebase command.

package/dist/src/types/commands/patches.d.ts

@@ -51,6 +51,28 @@ export interface PatchMetadata {
     sourceEsrVersion: string;
     /** Array of file paths affected by this patch */
     filesAffected: string[];
+    /**
+     * Optional per-patch list of lint check IDs to suppress when this patch
+     * is the target of `export`, `export-all`, or `re-export`. Exists for
+     * the class of patch that is advisory-noisy by nature — a cohesive
+     * branding bundle, a localised-resource pack, an auto-generated
+     * manifest — where the generic `large-patch-lines` / `large-patch-files`
+     * thresholds do not apply but `--skip-lint` (which silences *all*
+     * errors, not just the one that does not apply) is too coarse a hammer.
+     *
+     * Previously the only escape hatches were `--skip-lint` (blunt) or the
+     * full `rebase` flow (refreshes the same patch through a code path that
+     * silently skips `runPatchLint` — an asymmetry that forced operators
+     * through a multi-minute Firefox source re-download just to refresh
+     * one patch body).
+     *
+     * Values are free-form check IDs (e.g. `"large-patch-lines"`,
+     * `"large-patch-files"`). Checks not listed here still run normally.
+     * An entry for an unknown check ID is a no-op — the patch metadata
+     * documents the *intent* to suppress even if the check is later
+     * renamed or removed.
+     */
+    lintIgnore?: string[];
 }
 /**
  * Schema for patches/patches.json file.

package/dist/src/utils/fs.d.ts

@@ -78,6 +78,18 @@ export declare function writeFileAtomic(path: string, content: string | Buffer):
  * @param dest - Destination directory path
  */
 export declare function copyDir(src: string, dest: string): Promise<void>;
+/**
+ * Matches the atomic-temp-file shape emitted by `createAtomicTempPath`
+ * anywhere in a normalised (forward-slash) path. The `.fireforge-tmp-`
+ * marker plus a PID/UUID tail is unique to our own rename-based atomic
+ * writes, so callers (notably `status`) can filter these mid-flight
+ * artefacts out of their listings without racing the rename.
+ *
+ * Intentionally anchored so a legitimately-named backup file like
+ * `.notes.fireforge-tmp-backup` (no PID+UUID continuation) is NOT treated
+ * as one of our temps. The full shape is `.<filename>.fireforge-tmp-<pid>-<uuid>`.
+ */
+export declare const FIREFORGE_TMP_PATH_PATTERN: RegExp;
 /**
  * Checks available disk space at a path and warns via the provided
  * callback when it falls below `minBytes`.

package/dist/src/utils/fs.js

@@ -180,6 +180,18 @@ export async function copyDir(src, dest) {
         }
     }
 }
+/**
+ * Matches the atomic-temp-file shape emitted by `createAtomicTempPath`
+ * anywhere in a normalised (forward-slash) path. The `.fireforge-tmp-`
+ * marker plus a PID/UUID tail is unique to our own rename-based atomic
+ * writes, so callers (notably `status`) can filter these mid-flight
+ * artefacts out of their listings without racing the rename.
+ *
+ * Intentionally anchored so a legitimately-named backup file like
+ * `.notes.fireforge-tmp-backup` (no PID+UUID continuation) is NOT treated
+ * as one of our temps. The full shape is `.<filename>.fireforge-tmp-<pid>-<uuid>`.
+ */
+export const FIREFORGE_TMP_PATH_PATTERN = /(^|\/)\.[^/]+\.fireforge-tmp-\d+-[0-9a-f-]{36}$/i;
 /**
  * Generates a unique temp file path for atomic writes.
  *

package/dist/src/utils/paths.d.ts

@@ -1,5 +1,24 @@
 /** Converts Windows path separators to forward slashes for stable comparisons. */
 export declare function normalizePathSlashes(path: string): string;
+/**
+ * Strips a leading `engine/` (or `engine\\`) segment from a user-supplied
+ * path so the same command invocation accepts both repo-root-relative paths
+ * (`engine/browser/base/content/foo.js`) and engine-relative paths
+ * (`browser/base/content/foo.js`). The match is case-insensitive because
+ * default macOS and Windows filesystems treat `Engine/` and `engine/` as
+ * the same directory; a literal lowercase-only check previously left `mach`
+ * / the manifest writers resolving against a wrongly-cased prefix. Leading
+ * whitespace is ignored so tab-completed inputs don't slip past the strip.
+ *
+ * The return value is trimmed of the same leading whitespace when the
+ * prefix matched, and otherwise passed through verbatim — callers that
+ * care about internal whitespace can trim on their side.
+ *
+ * @param filePath Path as provided by the user
+ * @returns Path relative to the engine directory (or the original when the
+ *          prefix was absent)
+ */
+export declare function stripEnginePrefix(filePath: string): string;
 /** Checks whether a path is explicitly absolute on either POSIX or Windows. */
 export declare function isExplicitAbsolutePath(path: string): boolean;
 /** Resolves a candidate path and returns whether it stays within the given root. */

package/dist/src/utils/paths.js

@@ -2,10 +2,43 @@
 import { isAbsolute, relative, resolve } from 'node:path';
 const WINDOWS_ABSOLUTE_PATH = /^[a-zA-Z]:[\\/]/;
 const RELATIVE_PATH_ROOT = resolve('/__fireforge_path_root__');
+/**
+ * Matches a leading `engine/` or `engine\\` segment (case-insensitive,
+ * tolerates leading whitespace). Shared between `register`, `test`, `lint`,
+ * and `export` so every command that takes an engine-relative path accepts
+ * both the repo-root form (`engine/browser/...`) and the engine-relative
+ * form (`browser/...`) without diverging.
+ */
+const ENGINE_PREFIX_PATTERN = /^\s*engine[/\\]/i;
 /** Converts Windows path separators to forward slashes for stable comparisons. */
 export function normalizePathSlashes(path) {
     return path.replace(/\\/g, '/');
 }
+/**
+ * Strips a leading `engine/` (or `engine\\`) segment from a user-supplied
+ * path so the same command invocation accepts both repo-root-relative paths
+ * (`engine/browser/base/content/foo.js`) and engine-relative paths
+ * (`browser/base/content/foo.js`). The match is case-insensitive because
+ * default macOS and Windows filesystems treat `Engine/` and `engine/` as
+ * the same directory; a literal lowercase-only check previously left `mach`
+ * / the manifest writers resolving against a wrongly-cased prefix. Leading
+ * whitespace is ignored so tab-completed inputs don't slip past the strip.
+ *
+ * The return value is trimmed of the same leading whitespace when the
+ * prefix matched, and otherwise passed through verbatim — callers that
+ * care about internal whitespace can trim on their side.
+ *
+ * @param filePath Path as provided by the user
+ * @returns Path relative to the engine directory (or the original when the
+ *          prefix was absent)
+ */
+export function stripEnginePrefix(filePath) {
+    const match = ENGINE_PREFIX_PATTERN.exec(filePath);
+    if (match) {
+        return filePath.slice(match[0].length);
+    }
+    return filePath;
+}
 /** Checks whether a path is explicitly absolute on either POSIX or Windows. */
 export function isExplicitAbsolutePath(path) {
     return isAbsolute(path) || WINDOWS_ABSOLUTE_PATH.test(path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hominis/fireforge",
-  "version": "0.15.8",
+  "version": "0.16.0",
   "description": "FireForge — a build tool for customizing Firefox",
   "type": "module",
   "main": "./dist/src/index.js",