@hominis/fireforge 0.15.9 → 0.16.1

package/dist/src/commands/status.js

@@ -12,7 +12,7 @@ import { buildPatchQueueContext, collectNewFileCreatorsByPath } from '../core/pa
 import { loadPatchesManifest } from '../core/patch-manifest.js';
 import { GeneralError } from '../errors/base.js';
 import { toError } from '../utils/errors.js';
-import { pathExists, readText } from '../utils/fs.js';
+import { FIREFORGE_TMP_PATH_PATTERN, pathExists, readText } from '../utils/fs.js';
 import { info, intro, outro, verbose, warn } from '../utils/logger.js';
 /**
  * Status code descriptions for git status.
@@ -164,6 +164,21 @@ async function expandDirectoryEntries(files, engineDir) {
     }
     return { entries: expanded, truncations };
 }
+/**
+ * Strips entries whose path matches the atomic-temp-file shape
+ * FireForge's own `writeText` produces (see
+ * {@link import('../utils/fs.js').FIREFORGE_TMP_PATH_PATTERN}). Those
+ * files only exist for the duration of a write + rename and should
+ * never appear in `status` output; filtering them here keeps every
+ * status mode (default, raw, unmanaged, ownership, json) symmetric so
+ * the operator never sees a `.mozconfig.fireforge-tmp-<pid>-<uuid>`
+ * entry mid-write. Files named for unrelated reasons (e.g. a user's
+ * `.bashrc.fireforge-tmp-backup` without the PID+UUID tail) do not
+ * match the pattern and pass through unfiltered.
+ */
+function filterFireForgeTempFiles(files) {
+    return files.filter((entry) => !FIREFORGE_TMP_PATH_PATTERN.test(entry.file));
+}
 /**
  * Classifies files into patch-backed, unmanaged, or branding buckets.
  */
@@ -277,7 +292,11 @@ export async function statusCommand(projectRoot, options = {}) {
         const ownershipExpansion = (await isGitRepository(paths.engine))
             ? await expandDirectoryEntries(await getStatusWithCodes(paths.engine), paths.engine)
             : { entries: [], truncations: [] };
-        const rawFilesOwnership = ownershipExpansion.entries;
+        // Filter atomic-write temp files (Finding #18) so a mid-flight
+        // `.fireforge-tmp-<pid>-<uuid>` artefact never shows up in any
+        // status mode. The pattern is tight enough to let legitimately
+        // similar names through.
+        const rawFilesOwnership = filterFireForgeTempFiles(ownershipExpansion.entries);
         renderTruncationBanner(ownershipExpansion.truncations);
         // Only walk the patch bodies when the directory actually exists.
         // Fresh projects with no patch queue yet pass through with an empty
@@ -313,8 +332,28 @@ export async function statusCommand(projectRoot, options = {}) {
         throw new GeneralError('Engine directory is not a git repository. Run "fireforge download" to initialize.');
     }
     const rawFiles = await getStatusWithCodes(paths.engine);
-    const { entries: files, truncations } = await expandDirectoryEntries(rawFiles, paths.engine);
+    const { entries: expanded, truncations } = await expandDirectoryEntries(rawFiles, paths.engine);
+    // Strip atomic-write temp files (Finding #18) before every mode
+    // branch so raw / unmanaged / default / json all agree.
+    const files = filterFireForgeTempFiles(expanded);
     renderTruncationBanner(truncations);
+    // `--json` callers expect machine-parseable output on every invocation,
+    // including the clean-tree case. Before this ordering fix a clean tree
+    // printed "No modified files" / "Working tree clean" via the human
+    // branch below and `--json` was silently ignored, so scripts that piped
+    // the output through a JSON parser broke precisely when there was
+    // nothing to report. Emit `[]` here and return before the human fallback.
+    if (options.json) {
+        await renderJsonStatus(files, paths, projectRoot, config.binaryName);
+        return;
+    }
+    // `--raw` consumers parse the native `git status --porcelain` output
+    // directly. On a clean tree the raw mode should produce nothing on
+    // stdout — the human "Working tree clean" banner would contaminate the
+    // pipe. Short-circuit before the human clean-tree branch below.
+    if (options.raw && files.length === 0) {
+        return;
+    }
     if (files.length === 0) {
         info('No modified files');
         outro('Working tree clean');
@@ -325,11 +364,6 @@ export async function statusCommand(projectRoot, options = {}) {
         renderRawStatus(files);
         return;
     }
-    // JSON mode and default mode both need classification
-    if (options.json) {
-        await renderJsonStatus(files, paths, projectRoot, config.binaryName);
-        return;
-    }
     // Patch-aware classification
     const furnacePrefixes = await collectFurnaceManagedPrefixes(projectRoot);
     const classified = await classifyFiles(files, paths.engine, paths.patches, config.binaryName, furnacePrefixes);

package/dist/src/commands/test.js

@@ -11,28 +11,7 @@ import { AmbiguousBuildArtifactsError, BuildError } from '../errors/build.js';
 import { pathExists } from '../utils/fs.js';
 import { info, intro, spinner, warn } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
-/**
- * Strips a leading "engine/" or "engine\\" prefix from a path if present.
- * Users may specify paths like "engine/browser/modules/..." from the project
- * root, but mach test expects paths relative to the engine directory.
- *
- * The match is case-insensitive because case-insensitive filesystems
- * (default macOS, Windows) treat "Engine/" and "engine/" as the same
- * directory, and a literal lowercase-only check left mach with a
- * non-stripped prefix that resolved to a different path under the engine
- * tree. Tab and other whitespace before the prefix is also ignored.
- *
- * @param testPath - Path as provided by the user
- * @returns Path relative to the engine directory
- */
-function normalizeTestPath(testPath) {
-    const trimmed = testPath.trim();
-    const match = /^engine[/\\]/i.exec(trimmed);
-    if (match) {
-        return trimmed.slice(match[0].length);
-    }
-    return trimmed;
-}
+import { stripEnginePrefix } from '../utils/paths.js';
 async function assertTestPathsExist(engineDir, testPaths) {
     const missingPaths = [];
     for (const testPath of testPaths) {
@@ -198,8 +177,11 @@ export async function testCommand(projectRoot, testPaths, options = {}) {
             throw new GeneralError('Marionette preflight reported FAIL — see output above. Aborting before mach test runs.');
         }
     }
-    // Normalize test paths (strip engine/ prefix if present)
-    const normalizedPaths = testPaths.map(normalizeTestPath);
+    // Normalize test paths (strip engine/ prefix if present). Uses the
+    // shared `stripEnginePrefix` helper so `test`, `register`, `lint`, and
+    // `export` all accept the same prefix forms. Also trim to match the
+    // previous case-insensitive + leading-whitespace-tolerant contract.
+    const normalizedPaths = testPaths.map((p) => stripEnginePrefix(p).trim());
     await assertTestPathsExist(paths.engine, normalizedPaths);
     // Build extra args
     const extraArgs = [];

package/dist/src/commands/token.js

@@ -1,9 +1,10 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { Option } from 'commander';
 import { loadConfig } from '../core/config.js';
-import { loadFurnaceConfig } from '../core/furnace-config.js';
+import { furnaceConfigExists, loadFurnaceConfig } from '../core/furnace-config.js';
 import { addToken, getTokensCssPath, validateTokenAdd, } from '../core/token-manager.js';
 import { InvalidArgumentError } from '../errors/base.js';
+import { FurnaceError } from '../errors/furnace.js';
 import { toError } from '../utils/errors.js';
 import { info, intro, outro, success, warn } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
@@ -36,6 +37,18 @@ async function normalizeTokenNameForProject(projectRoot, rawTokenName) {
  */
 export async function tokenAddCommand(projectRoot, tokenName, value, options) {
     intro('Token Add');
+    // Finding #15: a fresh project without furnace.json failed deep inside
+    // the token-manager's `assertTokenCategoryExists` with "Token CSS file
+    // not found: browser/themes/shared/<binary>-tokens.css" — technically
+    // correct, but the operator's actual next step is to initialize
+    // Furnace (which scaffolds the tokens CSS file among other things).
+    // Catching the uninitialized case here gives the right guidance up-
+    // front before the generic "file not found" error fires.
+    if (!(await furnaceConfigExists(projectRoot))) {
+        throw new FurnaceError('Token management requires Furnace to be initialized. ' +
+            'Tokens live in the Furnace-managed tokens CSS file, which `fireforge furnace init` scaffolds alongside the rest of the Furnace workspace.\n\n' +
+            'Run "fireforge furnace init" first, then rerun "fireforge token add ...".');
+    }
     // Normalize token name using the configured Furnace token prefix when the
     // user supplied a bare token name like "canvas-gap".
     tokenName = await normalizeTokenNameForProject(projectRoot, tokenName);

package/dist/src/commands/watch.js

@@ -1,6 +1,6 @@
 import { getProjectPaths, loadConfig } from '../core/config.js';
 import { warnIfFurnaceStale } from '../core/furnace-staleness.js';
-import { buildArtifactMismatchMessage, generateMozconfig, hasBuildArtifacts, watchWithOutput, } from '../core/mach.js';
+import { buildArtifactMismatchMessage, generateMozconfig, hasBuildArtifacts, hasRunnableBundle, watchWithOutput, } from '../core/mach.js';
 import { GeneralError } from '../errors/base.js';
 import { AmbiguousBuildArtifactsError, BuildError } from '../errors/build.js';
 import { toError } from '../utils/errors.js';
@@ -114,7 +114,19 @@ export async function watchCommand(projectRoot) {
         throw new GeneralError(`Watch mode requires a completed build. ${detail}\n\n` +
             "Run 'fireforge build' first to create the initial build, then run 'fireforge watch'.");
     }
-    info(`Using build artifacts from ${buildCheck.objDir}/`);
+    // Report bundle state alongside the "Using build artifacts..." banner
+    // so an operator watching a mid-build tree can see why `fireforge run`
+    // would refuse right now while watch is still going. Watch remains
+    // permissive (it exists to drive rebuilds) — this is informational.
+    // The `hasBuildArtifacts` check already passed at this point, so
+    // `objDir` is always defined.
+    const bundleCheck = buildCheck.objDir
+        ? await hasRunnableBundle(paths.engine, config.binaryName, buildCheck.objDir)
+        : { runnable: false };
+    const bundleSuffix = bundleCheck.runnable
+        ? ' (bundle: runnable)'
+        : ' (bundle: pending — watch will rebuild)';
+    info(`Using build artifacts from ${buildCheck.objDir}/${bundleSuffix}`);
     // Advisory: warn when Furnace components have drifted since the last
     // apply so the user doesn't launch watch-mode builds with stale
     // components baked in. Mirrors the check in `fireforge run` — without

package/dist/src/commands/wire.js

@@ -10,7 +10,7 @@ import { toError } from '../utils/errors.js';
 import { pathExists } from '../utils/fs.js';
 import { info, intro, outro, success, warn } from '../utils/logger.js';
 import { pickDefined } from '../utils/options.js';
-import { isContainedRelativePath, isPathInsideRoot, toRootRelativePath } from '../utils/paths.js';
+import { isContainedRelativePath, isExplicitAbsolutePath, isPathInsideRoot, stripEnginePrefix, toRootRelativePath, } from '../utils/paths.js';
 const BROWSER_BASE_DIR = 'browser/base';
 function printWireDryRun(engineDir, name, subscriptDir, domFilePath, domTargetPath, options) {
     info('[dry-run] Would wire subscript:');
@@ -113,25 +113,51 @@ export async function wireCommand(projectRoot, name, options = {}) {
         }
         subscriptDir = options.subscriptDir;
     }
-    // Validate DOM fragment file exists and compute path relative to engine root
+    // Validate DOM fragment file exists and compute path relative to engine root.
+    //
+    // Accepts three shapes:
+    //  - Absolute paths (`/project/engine/browser/base/content/foo.inc.xhtml`)
+    //  - Repo-root-relative forms (`engine/browser/base/content/foo.inc.xhtml`)
+    //  - Engine-relative forms (`browser/base/content/foo.inc.xhtml`)
+    //
+    // Before the engine-prefix normalization, passing an `engine/…`-prefixed
+    // relative path from the repo root double-rooted through
+    // `toRootRelativePath(engineDir, …)` — `resolve(engineDir, 'engine/…')`
+    // landed at `engineDir/engine/…`, which is still "inside" engineDir but
+    // named as a second-level `engine/…` entry. The computed `#include`
+    // then read `../../../engine/browser/base/content/foo.inc.xhtml`,
+    // packaging-breaking nonsense. For absolute inputs this pre-existing
+    // contract was fine — `toRootRelativePath` handles absolute candidates
+    // correctly — so we only strip the prefix when the input is relative.
     let domFilePath;
     if (options.dom) {
         const paths = getProjectPaths(projectRoot);
-        if (!(await pathExists(options.dom))) {
+        const domCandidate = isExplicitAbsolutePath(options.dom)
+            ? options.dom
+            : stripEnginePrefix(options.dom);
+        if (!(await pathExists(domCandidate))) {
             throw new InvalidArgumentError(`DOM fragment file not found: ${options.dom}`, 'dom');
         }
-        if (!isPathInsideRoot(paths.engine, options.dom)) {
+        if (!isPathInsideRoot(paths.engine, domCandidate)) {
             throw new InvalidArgumentError(`DOM fragment file must stay within engine/: ${options.dom}`, 'dom');
         }
-        domFilePath = toRootRelativePath(paths.engine, options.dom);
+        domFilePath = toRootRelativePath(paths.engine, domCandidate);
     }
     // Resolve the chrome document the `#include` directive will land in.
     // Only consulted when `--dom` is supplied — we still resolve it here so
     // the dry-run plan can print the target accurately.
-    if (options.target !== undefined && !isContainedRelativePath(options.target)) {
-        throw new InvalidArgumentError(`Target chrome document must stay within engine/: ${options.target}`, 'target');
-    }
-    const domTargetPath = await resolveDomTargetPath(projectRoot, options.target);
+    //
+    // `stripEnginePrefix` is applied so `--target engine/browser/base/browser.xhtml`
+    // and `--target browser/base/browser.xhtml` are treated identically,
+    // matching the `--dom` normalization above. Absolute `--target` paths
+    // stay absolute (the containment check downstream rejects them).
+    const normalizedTarget = options.target !== undefined && !isExplicitAbsolutePath(options.target)
+        ? stripEnginePrefix(options.target)
+        : options.target;
+    if (normalizedTarget !== undefined && !isContainedRelativePath(normalizedTarget)) {
+        throw new InvalidArgumentError(`Target chrome document must stay within engine/: ${options.target ?? ''}`, 'target');
+    }
+    const domTargetPath = await resolveDomTargetPath(projectRoot, normalizedTarget);
     if (domFilePath) {
         const paths = getProjectPaths(projectRoot);
         if (!options.dryRun && !(await pathExists(join(paths.engine, domTargetPath)))) {

package/dist/src/core/branding.d.ts

@@ -6,6 +6,29 @@ export declare class BrandingError extends FireForgeError {
     readonly code: 6;
     get userMessage(): string;
 }
+/**
+ * Error thrown when the generated `mozconfig` references a `--with-branding`
+ * directory that does not match the branding tree FireForge set up. The
+ * mismatch is a silent-corruption hazard — `mach configure` picks the value
+ * from mozconfig but the scaffolded branding lives elsewhere, so the build
+ * fails deep inside moz.build resolution with a confusing "path does not
+ * exist" message. Surface it as an actionable preflight instead.
+ *
+ * The root cause is that setup renders templates under `configs/` with
+ * `${binaryName}` baked in at setup time; a subsequent edit to
+ * `fireforge.json`'s `binaryName` (or a re-setup without re-templating)
+ * leaves those baked-in names stale while `setupBranding` continues to use
+ * the current `config.binaryName`. Both directions (mozconfig ahead of
+ * config, config ahead of mozconfig) produce the same class of build break.
+ */
+export declare class BrandingMozconfigMismatchError extends FireForgeError {
+    readonly expectedBrandingDir: string;
+    readonly mozconfigBrandingDir: string;
+    readonly reason: 'mozconfig-missing-branding' | 'name-mismatch' | 'branding-dir-missing';
+    readonly code: 6;
+    constructor(expectedBrandingDir: string, mozconfigBrandingDir: string, reason: 'mozconfig-missing-branding' | 'name-mismatch' | 'branding-dir-missing');
+    get userMessage(): string;
+}
 /**
  * Full branding configuration.
  */

package/dist/src/core/branding.js

@@ -13,6 +13,45 @@ export class BrandingError extends FireForgeError {
         return `Branding Error: ${this.message}\n\nBranding is required to set MOZ_APP_VENDOR, MOZ_MACBUNDLE_ID, and other Firefox identity values.`;
     }
 }
+/**
+ * Error thrown when the generated `mozconfig` references a `--with-branding`
+ * directory that does not match the branding tree FireForge set up. The
+ * mismatch is a silent-corruption hazard — `mach configure` picks the value
+ * from mozconfig but the scaffolded branding lives elsewhere, so the build
+ * fails deep inside moz.build resolution with a confusing "path does not
+ * exist" message. Surface it as an actionable preflight instead.
+ *
+ * The root cause is that setup renders templates under `configs/` with
+ * `${binaryName}` baked in at setup time; a subsequent edit to
+ * `fireforge.json`'s `binaryName` (or a re-setup without re-templating)
+ * leaves those baked-in names stale while `setupBranding` continues to use
+ * the current `config.binaryName`. Both directions (mozconfig ahead of
+ * config, config ahead of mozconfig) produce the same class of build break.
+ */
+export class BrandingMozconfigMismatchError extends FireForgeError {
+    expectedBrandingDir;
+    mozconfigBrandingDir;
+    reason;
+    code = ExitCode.PATCH_ERROR;
+    constructor(expectedBrandingDir, mozconfigBrandingDir, reason) {
+        super(`Generated mozconfig references "${mozconfigBrandingDir}" but the active branding directory is "${expectedBrandingDir}".`);
+        this.expectedBrandingDir = expectedBrandingDir;
+        this.mozconfigBrandingDir = mozconfigBrandingDir;
+        this.reason = reason;
+    }
+    get userMessage() {
+        const diagnosis = this.reason === 'mozconfig-missing-branding'
+            ? `The generated mozconfig does not contain a --with-branding directive (found "${this.mozconfigBrandingDir}"). FireForge expected to write one for binaryName "${this.expectedBrandingDir}".`
+            : this.reason === 'name-mismatch'
+                ? `The generated mozconfig sets --with-branding="${this.mozconfigBrandingDir}" but FireForge set up branding under "${this.expectedBrandingDir}".`
+                : `The generated mozconfig sets --with-branding="${this.mozconfigBrandingDir}" but no moz.build exists under engine/${this.mozconfigBrandingDir}/.`;
+        return (`Branding Error: ${diagnosis}\n\n` +
+            'This usually means the rendered configs/ templates drifted from fireforge.json. Fix one of:\n' +
+            '  1. Edit configs/common.mozconfig so --with-branding uses ${binaryName} (or the current binaryName), then re-run "fireforge build".\n' +
+            '  2. Update fireforge.json so binaryName matches the --with-branding value baked into configs/.\n\n' +
+            'The mismatch is caught before mach builds because resolving the build against the wrong branding tree fails deep in moz.build with a confusing "path does not exist" message.');
+    }
+}
 /**
  * Sets up the custom branding directory for the browser.
  *

package/dist/src/core/browser-wire.js

@@ -1,8 +1,12 @@
 // SPDX-License-Identifier: EUPL-1.2
 import { join, relative } from 'node:path';
+import { GeneralError } from '../errors/base.js';
+import { toError } from '../utils/errors.js';
 import { toRootRelativePath } from '../utils/paths.js';
 import { getProjectPaths } from './config.js';
+import { createRollbackJournal, restoreRollbackJournal, snapshotFile } from './furnace-rollback.js';
 import { registerBrowserContent } from './manifest-register.js';
+import { DEFAULT_DOM_TARGET } from './wire-dom-fragment.js';
 import { addDestroyToBrowserInit, addDomFragment, addInitToBrowserInit, addSubscriptToBrowserMain, } from './wire-targets.js';
 export const DEFAULT_BROWSER_SUBSCRIPT_DIR = 'browser/base/content';
 const BROWSER_BASE_DIR = 'browser/base';
@@ -36,31 +40,72 @@ export async function wireSubscript(root, name, options = {}) {
             },
         };
     }
-    // 1. Add subscript to browser-main.js
-    const subscriptAdded = await addSubscriptToBrowserMain(engineDir, name);
-    // 2. Add init expression to browser-init.js (if provided)
-    let initAdded = false;
-    if (options.init) {
-        initAdded = await addInitToBrowserInit(engineDir, options.init, options.after);
+    // Snapshot every file the five mutation steps might touch so a mid-sequence
+    // failure (most commonly the chrome-document insertion not finding an
+    // anchor) does not leave a half-wired browser behind. Before the rollback
+    // journal landed here, a failed `wire` would still have written new
+    // `loadSubScript` calls into browser-main.js, new init/destroy expressions
+    // into browser-init.js, and a new entry into browser/base/jar.mn — the
+    // operator then had to grep the engine tree for the partial mutation and
+    // hand-revert, or re-download. The snapshots cover the targets on every
+    // code path (init/destroy/DOM are conditional, so we snapshot only when
+    // the corresponding option would fire a write) plus the two files every
+    // wire touches.
+    const journal = createRollbackJournal();
+    const effectiveDomTargetPath = options.domFilePath
+        ? toRootRelativePath(engineDir, options.domTargetPath ?? DEFAULT_DOM_TARGET)
+        : undefined;
+    await snapshotFile(journal, join(engineDir, 'browser/base/content/browser-main.js'));
+    if (options.init !== undefined || options.destroy !== undefined) {
+        await snapshotFile(journal, join(engineDir, 'browser/base/content/browser-init.js'));
     }
-    // 3. Add destroy expression to browser-init.js onUnload() (if provided)
-    let destroyAdded = false;
-    if (options.destroy) {
-        destroyAdded = await addDestroyToBrowserInit(engineDir, options.destroy);
+    if (effectiveDomTargetPath) {
+        await snapshotFile(journal, join(engineDir, effectiveDomTargetPath));
     }
-    // 4. Add #include directive to the top-level chrome document (if provided)
-    let domInserted = false;
-    if (options.domFilePath) {
-        domInserted = await addDomFragment(engineDir, toRootRelativePath(engineDir, options.domFilePath), options.domTargetPath);
+    await snapshotFile(journal, join(engineDir, 'browser/base/jar.mn'));
+    try {
+        // 1. Add subscript to browser-main.js
+        const subscriptAdded = await addSubscriptToBrowserMain(engineDir, name);
+        // 2. Add init expression to browser-init.js (if provided)
+        let initAdded = false;
+        if (options.init) {
+            initAdded = await addInitToBrowserInit(engineDir, options.init, options.after);
+        }
+        // 3. Add destroy expression to browser-init.js onUnload() (if provided)
+        let destroyAdded = false;
+        if (options.destroy) {
+            destroyAdded = await addDestroyToBrowserInit(engineDir, options.destroy);
+        }
+        // 4. Add #include directive to the top-level chrome document (if provided)
+        let domInserted = false;
+        if (options.domFilePath) {
+            domInserted = await addDomFragment(engineDir, toRootRelativePath(engineDir, options.domFilePath), options.domTargetPath);
+        }
+        // 5. Register in jar.mn
+        const jarMnResult = await registerBrowserContent(engineDir, `${name}.js`, undefined, jarMnSourcePath);
+        return {
+            subscriptAdded,
+            initAdded,
+            destroyAdded,
+            domInserted,
+            jarMnResult,
+        };
+    }
+    catch (error) {
+        // Best-effort rollback: if the restore itself fails, surface both the
+        // original wire failure and the rollback failure so the operator knows
+        // the engine may be in a partially-wired state that needs manual
+        // attention. The original error's message is preserved so the user sees
+        // *why* the wire failed (e.g. "Could not find insertion point in chrome
+        // document") alongside any rollback diagnosis.
+        const originalMessage = toError(error).message;
+        try {
+            await restoreRollbackJournal(journal);
+        }
+        catch (rollbackError) {
+            throw new GeneralError(`Wire failed: ${originalMessage}. Automatic rollback also failed: ${toError(rollbackError).message}. The engine may contain partially-applied wire mutations; review "git status" under engine/ and revert manually.`);
+        }
+        throw error;
     }
-    // 5. Register in jar.mn
-    const jarMnResult = await registerBrowserContent(engineDir, `${name}.js`, undefined, jarMnSourcePath);
-    return {
-        subscriptAdded,
-        initAdded,
-        destroyAdded,
-        domInserted,
-        jarMnResult,
-    };
 }
 //# sourceMappingURL=browser-wire.js.map

package/dist/src/core/build-baseline.d.ts

@@ -31,6 +31,20 @@ export interface BuildBaseline {
      * the project has since been renamed.
      */
     binaryName: string;
+    /**
+     * Content hash per packageable engine path that was dirty at build
+     * time (modified-against-HEAD or untracked). Used by
+     * `checkStaleBuildForTest` to distinguish "this file's content was
+     * already in `dist/` when the build completed" from "this file has
+     * been edited since". Missing on baselines written before 0.16.0; the
+     * stale-check falls back to the path-only comparison in that case,
+     * so older baselines retain their existing behavior.
+     *
+     * Keys are engine-relative POSIX paths. Values are hex-encoded
+     * SHA-256 digests of the file contents at the moment the baseline
+     * was recorded.
+     */
+    packageableFingerprints?: Record<string, string>;
 }
 /** Name of the last-build marker file under `.fireforge/`. */
 export declare const BUILD_BASELINE_FILENAME = "last-build.json";

package/dist/src/core/build-baseline.js

@@ -16,10 +16,17 @@
  * on successful build completion; a failed build does not update it, so a
  * subsequent run still audits against the last known-good tree.
  */
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { toError } from '../utils/errors.js';
 import { pathExists, readJson, writeJson } from '../utils/fs.js';
+import { verbose } from '../utils/logger.js';
+import { isPackageablePath } from './build-audit.js';
 import { FIREFORGE_DIR } from './config-paths.js';
-import { getHead, isMissingHeadError } from './git.js';
+import { getHead, hasChanges, isMissingHeadError } from './git.js';
+import { git } from './git-base.js';
+import { getUntrackedFiles } from './git-status.js';
 /** Name of the last-build marker file under `.fireforge/`. */
 export const BUILD_BASELINE_FILENAME = 'last-build.json';
 /**
@@ -73,11 +80,64 @@ export async function writeBuildBaseline(projectRoot, engineDir, binaryName) {
             throw error;
         }
     }
+    const packageableFingerprints = await collectPackageableFingerprints(engineDir);
     const baseline = {
         engineHeadSha,
         builtAt: new Date().toISOString(),
         binaryName,
+        ...(packageableFingerprints !== undefined ? { packageableFingerprints } : {}),
     };
     await writeJson(getBuildBaselinePath(projectRoot), baseline);
 }
+/**
+ * Reads the current engine workdir and computes a SHA-256 fingerprint
+ * for every packageable path that is either modified against HEAD or
+ * untracked. The stale-build preflight (`checkStaleBuildForTest`)
+ * compares the live fingerprint for each packageable-dirty file to
+ * the baseline's entry — paths where the hash matches are "the build
+ * already saw this exact content", paths where it differs (or that
+ * are new since the baseline) are genuinely stale.
+ *
+ * Returns `undefined` on any git failure so a broken probe never
+ * corrupts the on-disk baseline with `{}`; the stale-check then falls
+ * back to the pre-0.16.0 "path-only" behavior on the next test run.
+ */
+async function collectPackageableFingerprints(engineDir) {
+    try {
+        const dirtyPaths = new Set();
+        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)
+                    dirtyPaths.add(trimmed);
+            }
+            for (const untracked of await getUntrackedFiles(engineDir)) {
+                dirtyPaths.add(untracked);
+            }
+        }
+        const packageable = [...dirtyPaths].filter(isPackageablePath);
+        if (packageable.length === 0) {
+            return {};
+        }
+        const fingerprints = {};
+        for (const relPath of packageable) {
+            try {
+                const buffer = await readFile(join(engineDir, relPath));
+                fingerprints[relPath] = createHash('sha256').update(buffer).digest('hex');
+            }
+            catch (fileError) {
+                // A file that disappeared between status probe and hash is
+                // expected in concurrent scenarios; skip it without failing the
+                // whole baseline write.
+                verbose(`Build baseline: skipping fingerprint for ${relPath} — ${toError(fileError).message}`);
+            }
+        }
+        return fingerprints;
+    }
+    catch (error) {
+        verbose(`Build baseline: packageable fingerprint probe failed — ${toError(error).message}`);
+        return undefined;
+    }
+}
 //# sourceMappingURL=build-baseline.js.map

package/dist/src/core/config-mutate.d.ts

@@ -12,4 +12,4 @@ import type { FireForgeConfig } from '../types/config.js';
  * @returns The mutated config
  */
 export declare function mutateConfig(config: FireForgeConfig, key: string, value: unknown, skipValidation?: false): FireForgeConfig;
-export declare function mutateConfig(config: FireForgeConfig, key: string, value: unknown, skipValidation: true): Record<string, unknown>;
+export declare function mutateConfig(config: FireForgeConfig | Record<string, unknown>, key: string, value: unknown, skipValidation: true): Record<string, unknown>;

package/dist/src/core/config.d.ts

@@ -25,6 +25,23 @@ export declare function configExists(root: string): Promise<boolean>;
  * @throws Error if config doesn't exist or is invalid
  */
 export declare function loadConfig(root: string): Promise<FireForgeConfig>;
+/**
+ * Reads the raw `fireforge.json` document without running it through
+ * {@link validateConfig}. Returns every persisted key — including keys
+ * written via `fireforge config <key> --force` that `validateConfig`
+ * would strip from the typed result.
+ *
+ * Callers that need the validated, typed shape must still use
+ * {@link loadConfig}; this helper exists specifically for the `config`
+ * read path so `fireforge config <key>` can surface keys the write path
+ * accepted under `--force`.
+ *
+ * @param root - Root directory of the project
+ * @returns Raw config object as persisted on disk
+ * @throws ConfigNotFoundError when fireforge.json is missing
+ * @throws ConfigError when the file is not valid JSON
+ */
+export declare function loadRawConfigDocument(root: string): Promise<Record<string, unknown>>;
 /**
  * Writes a configuration to fireforge.json.
  * @param root - Root directory of the project

package/dist/src/core/config.js

@@ -50,6 +50,41 @@ export async function loadConfig(root) {
         throw new ConfigError(`Invalid fireforge.json at ${paths.config}: ${toError(error).message}`);
     }
 }
+/**
+ * Reads the raw `fireforge.json` document without running it through
+ * {@link validateConfig}. Returns every persisted key — including keys
+ * written via `fireforge config <key> --force` that `validateConfig`
+ * would strip from the typed result.
+ *
+ * Callers that need the validated, typed shape must still use
+ * {@link loadConfig}; this helper exists specifically for the `config`
+ * read path so `fireforge config <key>` can surface keys the write path
+ * accepted under `--force`.
+ *
+ * @param root - Root directory of the project
+ * @returns Raw config object as persisted on disk
+ * @throws ConfigNotFoundError when fireforge.json is missing
+ * @throws ConfigError when the file is not valid JSON
+ */
+export async function loadRawConfigDocument(root) {
+    const paths = getProjectPaths(root);
+    if (!(await pathExists(paths.config))) {
+        throw new ConfigNotFoundError(paths.config);
+    }
+    try {
+        const data = await readJson(paths.config);
+        if (data === null || typeof data !== 'object' || Array.isArray(data)) {
+            throw new ConfigError(`Invalid fireforge.json at ${paths.config}: expected an object`);
+        }
+        return data;
+    }
+    catch (error) {
+        if (error instanceof ConfigError || error instanceof ConfigNotFoundError) {
+            throw error;
+        }
+        throw new ConfigError(`Invalid fireforge.json at ${paths.config}: ${toError(error).message}`);
+    }
+}
 /**
  * Writes a configuration to fireforge.json.
  * @param root - Root directory of the project