@hominis/fireforge 0.35.0 → 0.37.0

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

@@ -15,7 +15,7 @@
  * on successful build completion; a failed build does not update it, so a
  * subsequent run still audits against the last known-good tree.
  */
-import type { BuildBaseline } from './build-baseline-types.js';
+import type { BuildBaseline, TestPackagingCoverage } from './build-baseline-types.js';
 /** Name of the last-build marker file under `.fireforge/`. */
 export declare const BUILD_BASELINE_FILENAME = "last-build.json";
 /**
@@ -39,5 +39,8 @@ export declare function readBuildBaseline(projectRoot: string): Promise<BuildBas
  * @param projectRoot - Root directory of the project
  * @param engineDir - Path to the engine directory
  * @param binaryName - Current `binaryName` from fireforge.json
+ * @param testPackagingCoverage - Coverage claim of the packaged test
+ *   runtime this build produced (`'full'`, or the scoped request paths of
+ *   a `test --build` invocation). Omitted → field left off the marker.
  */
-export declare function writeBuildBaseline(projectRoot: string, engineDir: string, binaryName: string): Promise<void>;
+export declare function writeBuildBaseline(projectRoot: string, engineDir: string, binaryName: string, testPackagingCoverage?: TestPackagingCoverage): Promise<void>;

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

@@ -65,8 +65,11 @@ export async function readBuildBaseline(projectRoot) {
  * @param projectRoot - Root directory of the project
  * @param engineDir - Path to the engine directory
  * @param binaryName - Current `binaryName` from fireforge.json
+ * @param testPackagingCoverage - Coverage claim of the packaged test
+ *   runtime this build produced (`'full'`, or the scoped request paths of
+ *   a `test --build` invocation). Omitted → field left off the marker.
  */
-export async function writeBuildBaseline(projectRoot, engineDir, binaryName) {
+export async function writeBuildBaseline(projectRoot, engineDir, binaryName, testPackagingCoverage) {
     let engineHeadSha = '';
     try {
         engineHeadSha = await getHead(engineDir);
@@ -86,6 +89,7 @@ export async function writeBuildBaseline(projectRoot, engineDir, binaryName) {
         builtAt: new Date().toISOString(),
         binaryName,
         ...(packageableFingerprints !== undefined ? { packageableFingerprints } : {}),
+        ...(testPackagingCoverage !== undefined ? { testPackagingCoverage } : {}),
     };
     await writeJson(getBuildBaselinePath(projectRoot), baseline);
 }
@@ -140,4 +144,3 @@ async function collectPackageableFingerprints(engineDir) {
         return undefined;
     }
 }
-//# sourceMappingURL=build-baseline.js.map

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

@@ -13,6 +13,7 @@ import { collectChangedEnginePaths } from './engine-changes.js';
 import { applyAllComponents } from './furnace-apply.js';
 import { furnaceConfigExists, getFurnacePaths, loadFurnaceConfig, loadFurnaceState, } from './furnace-config.js';
 import { runFurnaceMutation } from './furnace-operation.js';
+import { countEntriesWithBlockingStepErrors } from './furnace-step-errors.js';
 import { cleanStories } from './furnace-stories.js';
 import { generateMozconfig, runMachCapture } from './mach.js';
 import { explainMachError } from './mach-error-hints.js';
@@ -169,7 +170,7 @@ export async function prepareBuildEnvironment(projectRoot, paths, config, option
             // These are distinct from `result.errors`, which captures
             // components that failed before reaching the applied list at all.
             // The sum of the two is the total count of failed components.
-            const appliedWithStepErrorsCount = result.applied.filter((entry) => (entry.stepErrors?.length ?? 0) > 0).length;
+            const appliedWithStepErrorsCount = countEntriesWithBlockingStepErrors(result.applied);
             const totalApplyFailures = result.errors.length + appliedWithStepErrorsCount;
             if (totalApplyFailures > 0) {
                 furnaceSpinner.error('Failed to apply Furnace components');
@@ -210,4 +211,3 @@ export async function prepareBuildEnvironment(projectRoot, paths, config, option
     }
     return { furnaceApplied, reconfigured };
 }
-//# sourceMappingURL=build-prepare.js.map

package/dist/src/core/config-mutate.js

@@ -70,4 +70,3 @@ export function mutateConfig(config, key, value, skipValidation = false) {
     }
     return raw;
 }
-//# sourceMappingURL=config-mutate.js.map

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

@@ -9,9 +9,9 @@ export declare const FIREFORGE_DIR = ".fireforge";
 /** Name of the state file */
 export declare const STATE_FILENAME = "state.json";
 /** Supported top-level fireforge.json keys backed by the current schema. */
-export declare const SUPPORTED_CONFIG_ROOT_KEYS: readonly ["name", "vendor", "appId", "binaryName", "firefox", "build", "license", "wire", "patchLint", "patchPolicy", "typecheck", "markerComment"];
+export declare const SUPPORTED_CONFIG_ROOT_KEYS: readonly ["name", "vendor", "appId", "binaryName", "firefox", "build", "test", "externalToolchains", "license", "wire", "patchLint", "patchPolicy", "typecheck", "markerComment"];
 /** Supported config paths that can be read or set without --force. */
-export declare const SUPPORTED_CONFIG_PATHS: readonly ["name", "vendor", "appId", "binaryName", "license", "firefox", "firefox.version", "firefox.product", "firefox.sha256", "build", "build.jobs", "wire", "wire.subscriptDir", "patchLint", "patchLint.checkJs", "patchLint.checkJsStrict", "patchLint.checkJsCompilerOptions", "patchLint.checkJsExtraShim", "patchLint.rawColorAllowlist", "patchLint.jsdocClassMethods", "patchLint.testAssertionFloor", "patchLint.chromeScriptJsDoc", "patchPolicy", "typecheck", "typecheck.projects", "typecheck.extraShim", "markerComment"];
+export declare const SUPPORTED_CONFIG_PATHS: readonly ["name", "vendor", "appId", "binaryName", "license", "firefox", "firefox.version", "firefox.product", "firefox.sha256", "build", "build.jobs", "test", "test.canaryPath", "test.canaryTimeoutSeconds", "externalToolchains", "wire", "wire.subscriptDir", "patchLint", "patchLint.checkJs", "patchLint.checkJsStrict", "patchLint.checkJsCompilerOptions", "patchLint.checkJsExtraShim", "patchLint.rawColorAllowlist", "patchLint.jsdocClassMethods", "patchLint.testAssertionFloor", "patchLint.chromeScriptJsDoc", "patchPolicy", "typecheck", "typecheck.projects", "typecheck.extraShim", "markerComment"];
 /**
  * Gets all project paths based on a root directory.
  * @param root - Root directory of the project

package/dist/src/core/config-paths.js

@@ -25,6 +25,8 @@ export const SUPPORTED_CONFIG_ROOT_KEYS = [
     'binaryName',
     'firefox',
     'build',
+    'test',
+    'externalToolchains',
     'license',
     'wire',
     'patchLint',
@@ -45,6 +47,10 @@ export const SUPPORTED_CONFIG_PATHS = [
     'firefox.sha256',
     'build',
     'build.jobs',
+    'test',
+    'test.canaryPath',
+    'test.canaryTimeoutSeconds',
+    'externalToolchains',
     'wire',
     'wire.subscriptDir',
     'patchLint',
@@ -81,4 +87,3 @@ export function getProjectPaths(root) {
         componentsDir: join(root, 'components'),
     };
 }
-//# sourceMappingURL=config-paths.js.map

package/dist/src/core/config-state.js

@@ -149,4 +149,3 @@ export async function updateState(root, updates) {
         await writeJson(paths.state, validateFireForgeState(nextState));
     });
 }
-//# sourceMappingURL=config-state.js.map

package/dist/src/core/config-validate-patch-policy.js

@@ -172,4 +172,3 @@ export function parsePatchPolicyBlock(rec) {
     }
     return out;
 }
-//# sourceMappingURL=config-validate-patch-policy.js.map

package/dist/src/core/config-validate-test-toolchains.d.ts

@@ -0,0 +1,8 @@
+import type { FireForgeConfig } from '../types/config.js';
+import { parseObject } from '../utils/parse.js';
+type ConfigRecord = ReturnType<typeof parseObject>;
+/** Parses the optional `test` block. */
+export declare function parseTestBlock(rec: ConfigRecord, config: FireForgeConfig): void;
+/** Parses optional project-specific external toolchain doctor probes. */
+export declare function parseExternalToolchainsBlock(rec: ConfigRecord, config: FireForgeConfig): void;
+export {};

package/dist/src/core/config-validate-test-toolchains.js

@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { ConfigError } from '../errors/config.js';
+import { parseObject } from '../utils/parse.js';
+import { isContainedRelativePath } from '../utils/paths.js';
+function optionalConfigString(rec, key, label) {
+    const value = rec.raw(key);
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string') {
+        throw new ConfigError(`Config field "${label}" must be a string`);
+    }
+    return value;
+}
+function optionalConfigObject(rec, key) {
+    const value = rec.raw(key);
+    if (value === undefined)
+        return undefined;
+    try {
+        return rec.object(key);
+    }
+    catch {
+        throw new ConfigError(`Config field "${key}" must be an object`);
+    }
+}
+/** Parses the optional `test` block. */
+export function parseTestBlock(rec, config) {
+    const testRec = optionalConfigObject(rec, 'test');
+    if (!testRec)
+        return;
+    const out = {};
+    const canaryPath = optionalConfigString(testRec, 'canaryPath', 'test.canaryPath');
+    if (canaryPath !== undefined) {
+        if (canaryPath.trim() === '' || !isContainedRelativePath(canaryPath)) {
+            throw new ConfigError('Config field "test.canaryPath" must be a project-relative path');
+        }
+        out.canaryPath = canaryPath;
+    }
+    const canaryTimeout = testRec.raw('canaryTimeoutSeconds');
+    if (canaryTimeout !== undefined) {
+        if (typeof canaryTimeout !== 'number' ||
+            !Number.isInteger(canaryTimeout) ||
+            canaryTimeout < 1 ||
+            canaryTimeout > 600) {
+            throw new ConfigError('Config field "test.canaryTimeoutSeconds" must be an integer in 1..600');
+        }
+        out.canaryTimeoutSeconds = canaryTimeout;
+    }
+    config.test = out;
+}
+/** Parses optional project-specific external toolchain doctor probes. */
+export function parseExternalToolchainsBlock(rec, config) {
+    const raw = rec.raw('externalToolchains');
+    if (raw === undefined)
+        return;
+    if (!Array.isArray(raw)) {
+        throw new ConfigError('Config field "externalToolchains" must be an array');
+    }
+    config.externalToolchains = raw.map((entry, index) => {
+        if (typeof entry !== 'object' || entry === null || Array.isArray(entry)) {
+            throw new ConfigError(`Config field "externalToolchains[${String(index)}]" must be an object`);
+        }
+        const item = entry;
+        const name = item['name'];
+        if (typeof name !== 'string' || name.trim() === '') {
+            throw new ConfigError(`Config field "externalToolchains[${String(index)}].name" must be a non-empty string`);
+        }
+        const tools = item['tools'];
+        if (!Array.isArray(tools) || tools.length === 0) {
+            throw new ConfigError(`Config field "externalToolchains[${String(index)}].tools" must be a non-empty array`);
+        }
+        return {
+            name,
+            tools: tools.map((tool, toolIndex) => parseExternalToolRequirement(tool, index, toolIndex)),
+        };
+    });
+}
+function parseExternalToolRequirement(tool, index, toolIndex) {
+    const label = `externalToolchains[${String(index)}].tools[${String(toolIndex)}]`;
+    if (typeof tool !== 'object' || tool === null || Array.isArray(tool)) {
+        throw new ConfigError(`Config field "${label}" must be an object`);
+    }
+    const toolRec = tool;
+    const toolName = toolRec['name'];
+    if (typeof toolName !== 'string' || toolName.trim() === '') {
+        throw new ConfigError(`Config field "${label}.name" must be a non-empty string`);
+    }
+    const toolPath = toolRec['path'];
+    if (toolPath !== undefined && (typeof toolPath !== 'string' || toolPath.trim() === '')) {
+        throw new ConfigError(`Config field "${label}.path" must be a non-empty string`);
+    }
+    const xcrun = toolRec['xcrun'];
+    if (xcrun !== undefined && typeof xcrun !== 'boolean') {
+        throw new ConfigError(`Config field "${label}.xcrun" must be a boolean`);
+    }
+    const required = toolRec['required'];
+    if (required !== undefined && typeof required !== 'boolean') {
+        throw new ConfigError(`Config field "${label}.required" must be a boolean`);
+    }
+    return {
+        name: toolName,
+        ...(toolPath !== undefined ? { path: toolPath } : {}),
+        ...(xcrun !== undefined ? { xcrun } : {}),
+        ...(required !== undefined ? { required } : {}),
+    };
+}

package/dist/src/core/config-validate.js

@@ -9,6 +9,7 @@ import { isContainedRelativePath, isExplicitAbsolutePath } from '../utils/paths.
 import { isValidAppId, isValidFirefoxVersion, isValidProjectLicense, PROJECT_LICENSES, validateFirefoxProductVersionCompatibility, } from '../utils/validation.js';
 import { SUPPORTED_CONFIG_ROOT_KEYS } from './config-paths.js';
 import { parsePatchPolicyBlock } from './config-validate-patch-policy.js';
+import { parseExternalToolchainsBlock, parseTestBlock } from './config-validate-test-toolchains.js';
 /**
  * Parses and validates the four required identity fields (`name`,
  * `vendor`, `appId`, `binaryName`): all non-empty strings, with
@@ -145,6 +146,8 @@ export function validateConfig(data) {
     const firefox = parseFirefoxBlock(rec);
     const config = { ...identity, firefox };
     parseBuildBlock(rec, config);
+    parseTestBlock(rec, config);
+    parseExternalToolchainsBlock(rec, config);
     parseWireBlock(rec, config);
     parseLicenseField(rec, config);
     // Marker comment — appended to lines FireForge writes into upstream files.
@@ -429,4 +432,3 @@ function parseTypecheckProjectOverrides(raw, projects) {
     }
     return out;
 }
-//# sourceMappingURL=config-validate.js.map

package/dist/src/core/config.js

@@ -149,4 +149,3 @@ export async function withConfigFileLock(root, operation) {
             `(age: ${Math.round(ageMs / 1000)}s). A previous fireforge process may have crashed.`,
     });
 }
-//# sourceMappingURL=config.js.map

package/dist/src/core/destructive.js

@@ -134,4 +134,3 @@ export async function appendHistory(patchesDir, entry) {
     const line = `${JSON.stringify(record)}\n`;
     await appendFile(join(patchesDir, HISTORY_LOG_FILENAME), line, 'utf-8');
 }
-//# sourceMappingURL=destructive.js.map

package/dist/src/core/diff-hunks.js

@@ -194,7 +194,6 @@ function coalescedHunk(oldLines, newLines, context) {
         return [];
     }
     const contextStart = Math.max(0, firstDiff - context);
-    const contextEndOld = Math.min(oldLines.length - 1, lastOldDiff + context);
     const contextEndNew = Math.min(newLines.length - 1, lastNewDiff + context);
     const hunkLines = [];
     for (let k = contextStart; k < firstDiff; k++) {
@@ -206,13 +205,21 @@ function coalescedHunk(oldLines, newLines, context) {
     for (let k = firstDiff; k <= lastNewDiff; k++) {
         hunkLines.push({ marker: '+', content: newLines[k] });
     }
-    const trailingStart = Math.max(lastOldDiff + 1, lastNewDiff + 1);
-    const trailingEnd = Math.max(contextEndOld, contextEndNew);
-    for (let k = trailingStart; k <= trailingEnd && k < newLines.length; k++) {
+    // Trailing context comes from the common suffix, which lives at
+    // DIFFERENT indices on each side (lastOldDiff+1… vs lastNewDiff+1…).
+    // The previous mixed-coordinate loop (max() of both sides indexing
+    // newLines) emitted wrong context on asymmetric edits, and the trailing
+    // lines were excluded from the @@ header lengths entirely — so on
+    // >LCS_LINE_LIMIT files the rendered header disagreed with the body.
+    for (let k = lastNewDiff + 1; k <= contextEndNew; k++) {
         hunkLines.push({ marker: ' ', content: newLines[k] });
     }
-    const oldLength = lastOldDiff - firstDiff + 1 + (firstDiff - contextStart);
-    const newLength = lastNewDiff - firstDiff + 1 + (firstDiff - contextStart);
+    const leadingContext = firstDiff - contextStart;
+    // Common-suffix symmetry: oldLen-1-lastOldDiff === newLen-1-lastNewDiff,
+    // so both sides clamp to the same trailing context count.
+    const trailingContext = contextEndNew - lastNewDiff;
+    const oldLength = lastOldDiff - firstDiff + 1 + leadingContext + trailingContext;
+    const newLength = lastNewDiff - firstDiff + 1 + leadingContext + trailingContext;
     return [
         {
             oldStart: contextStart + 1,
@@ -265,4 +272,3 @@ export function renderHunks(hunks) {
     }
     return out;
 }
-//# sourceMappingURL=diff-hunks.js.map

package/dist/src/core/engine-changes.js

@@ -61,4 +61,3 @@ export async function collectChangedEnginePaths(engineDir, baseline, contextLabe
     }
     return [...collected].sort();
 }
-//# sourceMappingURL=engine-changes.js.map

package/dist/src/core/engine-session-lock.d.ts

@@ -0,0 +1,12 @@
+/**
+ *
+ */
+export declare function withEngineSessionLock<T>(projectRoot: string, command: string, operation: () => Promise<T>): Promise<T>;
+/**
+ *
+ */
+export declare function snapshotEngineGeneration(engineDir: string): Promise<string>;
+/**
+ *
+ */
+export declare function assertEngineGenerationUnchanged(engineDir: string, before: string): Promise<void>;

package/dist/src/core/engine-session-lock.js

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { join } from 'node:path';
+import { GeneralError } from '../errors/base.js';
+import { withFileLock } from './file-lock.js';
+import { git } from './git-base.js';
+const ENGINE_SESSION_LOCK_PATH = join('.fireforge', 'engine-session.lock');
+/**
+ *
+ */
+export async function withEngineSessionLock(projectRoot, command, operation) {
+    if (process.env['FIREFORGE_ENABLE_ENGINE_SESSION_LOCK_IN_TEST'] !== '1' &&
+        (process.env['NODE_ENV'] === 'test' || process.env['VITEST'] !== undefined)) {
+        return operation();
+    }
+    return withFileLock(join(projectRoot, ENGINE_SESSION_LOCK_PATH), operation, {
+        timeoutMs: 1000,
+        ownerMetadata: [`command=${command}`, `started=${new Date().toISOString()}`],
+        onTimeoutMessage: `Another FireForge engine-mutating command is already running. ` +
+            `Wait for it to finish, then retry \`${command}\`.`,
+        onStaleLockMessage: (ageMs) => `Removed stale FireForge engine session lock (${Math.round(ageMs / 1000)}s old).`,
+    });
+}
+/**
+ *
+ */
+export async function snapshotEngineGeneration(engineDir) {
+    try {
+        const head = (await git(['rev-parse', 'HEAD'], engineDir)).trim();
+        const status = await git(['status', '--porcelain=v1', '-z'], engineDir);
+        return `${head}\0${status}`;
+    }
+    catch (error) {
+        return `unavailable:${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+/**
+ *
+ */
+export async function assertEngineGenerationUnchanged(engineDir, before) {
+    const after = await snapshotEngineGeneration(engineDir);
+    if (after === before)
+        return;
+    throw new GeneralError('engine/ changed while `fireforge test` was running, so this test verdict is invalid/inconclusive.\n\n' +
+        'Use one writer per engine checkout, then rebuild and rerun the affected tests.');
+}

package/dist/src/core/file-lock.d.ts

@@ -2,8 +2,16 @@ export interface FileLockOptions {
     timeoutMs?: number;
     pollMs?: number;
     staleMs?: number;
+    /**
+     * Interval between stale-lock probes while waiting (defaults to
+     * {@link STALE_REPROBE_INTERVAL_MS}). Exists mainly so tests can exercise
+     * the mid-wait reaping path without multi-second sleeps.
+     */
+    staleReprobeMs?: number;
     onTimeoutMessage?: string;
     onStaleLockMessage?: (ageMs: number) => string | undefined;
+    /** Extra owner-file lines for human diagnostics; ignored by lock mechanics. */
+    ownerMetadata?: readonly string[];
 }
 /** Derives the sibling lock-directory path used to guard a file-based resource. */
 export declare function createSiblingLockPath(filePath: string, suffix?: string): string;