@hominis/fireforge 0.15.5 → 0.15.7

package/dist/src/core/test-stale-check.js

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: EUPL-1.2
+/*
+ * Stale-build preflight for `fireforge test`.
+ *
+ * Without this preflight, an operator who edits engine chrome / packaged
+ * resources (`jar.mn` entries, `.xhtml`/`.mjs`/`.css` under chrome trees,
+ * pref files) and then runs `fireforge test <path>` only discovers the
+ * build is stale AFTER xpcshell / mach test starts and errors out with
+ * `NS_ERROR_FILE_NOT_FOUND` against a `chrome://browser/content/…` URI
+ * — which reads as a test bug, not a rebuild prompt. The motivating case
+ * was scaffolding a new top-level chrome document + BrowserGlue-style
+ * xpcshell test: the test file existed, the manifests were registered,
+ * but `dist/` still held the pre-edit bundle and chrome URIs resolved
+ * to nothing.
+ *
+ * This preflight diffs engine HEAD (or workdir) against the last-build
+ * baseline (`.fireforge/last-build.json`), filters to paths that imply
+ * packaging, and returns a compact summary. `fireforge test` prints a
+ * warning up-front so the operator sees "you edited X, Y, Z since the
+ * last build — rerun with `--build` to refresh" BEFORE mach test
+ * launches. Detection stays advisory (warn-only) because a fork that
+ * rebuilds out-of-band (a separate `./mach build` invocation, an IDE
+ * plugin, etc.) can legitimately have a fresh `dist/` with no
+ * FireForge-recorded baseline update.
+ */
+import { toError } from '../utils/errors.js';
+import { verbose } from '../utils/logger.js';
+import { isPackageablePath } from './build-audit.js';
+import { readBuildBaseline } from './build-baseline.js';
+import { hasChanges, isMissingHeadError } from './git.js';
+import { git } from './git-base.js';
+import { getUntrackedFiles } from './git-status.js';
+/** Cap on the number of changed paths rendered inline. */
+const STALE_PATHS_LIMIT = 10;
+/**
+ * Collects engine paths that changed since the baseline SHA plus any
+ * workdir modifications. Mirrors the helper inside `build-prepare.ts` but
+ * is kept separate so the test-side preflight does not need to pull in
+ * the full build-prepare dependency graph (mozconfig generation, furnace
+ * apply hooks, …).
+ */
+async function collectChangedEnginePaths(engineDir, baseline) {
+    const collected = new Set();
+    if (baseline.engineHeadSha) {
+        try {
+            const diff = await git(['diff', '--name-only', `${baseline.engineHeadSha}..HEAD`], engineDir);
+            for (const line of diff.split('\n')) {
+                const trimmed = line.trim();
+                if (trimmed)
+                    collected.add(trimmed);
+            }
+        }
+        catch (error) {
+            if (!isMissingHeadError(error)) {
+                verbose(`Stale-build preflight: could not diff engine against baseline — ${toError(error).message}`);
+            }
+        }
+    }
+    try {
+        if (await hasChanges(engineDir)) {
+            const worktreeDiff = await git(['diff', '--name-only', 'HEAD'], engineDir);
+            for (const line of worktreeDiff.split('\n')) {
+                const trimmed = line.trim();
+                if (trimmed)
+                    collected.add(trimmed);
+            }
+            for (const untracked of await getUntrackedFiles(engineDir)) {
+                collected.add(untracked);
+            }
+        }
+    }
+    catch (error) {
+        verbose(`Stale-build preflight: could not enumerate workdir changes — ${toError(error).message}`);
+    }
+    return [...collected];
+}
+/**
+ * Probes the engine tree for packageable changes since the last successful
+ * `fireforge build`. Returns a summary the `fireforge test` handler renders
+ * as an up-front warning when `--build` was NOT passed. The probe never
+ * throws; git failures and a missing baseline both degrade to `stale: false`
+ * so a broken probe cannot block a test run.
+ *
+ * @param projectRoot Root directory of the project.
+ * @param engineDir Path to the engine directory.
+ */
+export async function checkStaleBuildForTest(projectRoot, engineDir) {
+    const baseline = await readBuildBaseline(projectRoot);
+    if (!baseline) {
+        return { stale: false, changedPaths: [], truncated: 0, baseline: undefined };
+    }
+    const changed = await collectChangedEnginePaths(engineDir, baseline);
+    const packageable = changed.filter((path) => isPackageablePath(path)).sort();
+    if (packageable.length === 0) {
+        return { stale: false, changedPaths: [], truncated: 0, baseline };
+    }
+    const head = packageable.slice(0, STALE_PATHS_LIMIT);
+    const truncated = Math.max(0, packageable.length - head.length);
+    return { stale: true, changedPaths: head, truncated, baseline };
+}
+/**
+ * Formats a human-readable warning body from a {@link StaleBuildResult}.
+ * Kept separate from the probe so test code can assert on the structured
+ * result without matching the rendered copy.
+ */
+export function formatStaleBuildWarning(result) {
+    const tail = result.truncated > 0 ? `, … (+${result.truncated} more)` : '';
+    const list = result.changedPaths.join(', ') + tail;
+    return (`Engine tree has changed since the last successful fireforge build (${list}).\n` +
+        'The current obj-*/dist/ bundle may not reflect those edits. If your test reads ' +
+        'packaged chrome / jar.mn resources, rerun with "fireforge test --build" (or ' +
+        '"fireforge build --ui") first. Passing --build skips this check.');
+}
+//# sourceMappingURL=test-stale-check.js.map

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

@@ -41,6 +41,14 @@ export interface BuildOptions {
     jobs?: number;
     /** Brand to build (stable, esr, etc.) */
     brand?: string;
+    /**
+     * When a mozinfo mismatch is detected that looks like a safe path
+     * relocation (same structure, different prefix), patch mozinfo paths
+     * in place and run `mach configure` rather than aborting with a
+     * full-rebuild instruction. Falls back to the original abort message
+     * for any mismatch the rewriter cannot prove safe.
+     */
+    rewriteMozinfo?: boolean;
 }
 /**
  * Options for the export command.
@@ -298,6 +306,14 @@ export interface FurnaceCreateOptions {
     testStyle?: 'mochikit' | 'browser-chrome' | 'xpcshell';
     /** Stock component tag names composed internally by this component */
     compose?: string[];
+    /**
+     * Show the planned file set and furnace.json changes without writing
+     * anything. All validation that does not require disk writes (tag name
+     * shape, name conflicts, engine pre-existence, `--compose` targets, cycle
+     * detection, prefix warning) runs before the plan is emitted, so a
+     * dry-run faithfully previews the real command's outcome.
+     */
+    dryRun?: boolean;
 }
 /**
  * Options for the wire command.

package/package.json

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