@hominis/fireforge 0.49.2 → 0.50.0

package/dist/src/core/build-run-record.d.ts

@@ -0,0 +1,74 @@
+/**
+ * A record of the mach build in flight, kept in `.fireforge/build-run.json`
+ * so any session on the checkout can see why the bundle is missing.
+ *
+ * An interrupted `fireforge build` (a killed peer session, a closed
+ * terminal) can leave `dist/<App>.app/Contents/MacOS/` without its
+ * executable. Every later `fireforge test`, in every session, then failed
+ * at launch with nothing saying a build had died there, and the sessions
+ * that had not run the build had no way to find out.
+ *
+ * The record is written when a protected mach build starts and removed when
+ * it succeeds. A failed build leaves it with `status: "failed"` and the exit
+ * code. A build that never reached either end, because its process died,
+ * leaves `status: "running"` with a PID that no longer exists, which is how
+ * an interrupted run is recognized. The next build that runs to the end
+ * replaces whatever was there.
+ *
+ * Best-effort throughout: a build never fails because its record could not
+ * be written, and an unreadable record reads as "no record".
+ */
+/** The persisted record. */
+interface BuildRunRecord {
+    /** Whether the build is (or was last seen) running, or ended in failure. */
+    status: 'running' | 'failed';
+    /** PID of the FireForge process that ran the build. */
+    pid: number;
+    /** That process's boot-relative start tick, where procfs exposes one. */
+    startTick?: number;
+    /** The FireForge invocation, e.g. `fireforge build --ui`. */
+    command: string;
+    /** The mach command, e.g. `mach build faster`. */
+    machCommand: string;
+    /** ISO time the mach build started. */
+    startedAt: string;
+    /** ISO time a failed build ended. */
+    endedAt?: string;
+    /** Exit code of a failed build, when mach returned one. */
+    exitCode?: number;
+}
+/** What the record says about the last build. */
+export type BuildRunState = {
+    kind: 'none';
+} | {
+    kind: 'running' | 'interrupted' | 'failed';
+    record: BuildRunRecord;
+};
+/**
+ * Runs a mach build with its run record maintained around it. The record
+ * is removed on a zero exit and kept as `failed` on a non-zero exit or a
+ * throw, so only a build whose process died mid-run is left `running`.
+ *
+ * @param projectRoot - Project root holding `.fireforge/`
+ * @param machCommand - The mach command being run
+ * @param build - The build itself
+ * @returns Whatever the build returned
+ */
+export declare function withBuildRunRecord<T extends {
+    exitCode: number;
+}>(projectRoot: string, machCommand: string, build: () => Promise<T>): Promise<T>;
+/**
+ * Reads the last build's record and decides whether its process is still
+ * running.
+ *
+ * @param projectRoot - Project root holding `.fireforge/`
+ */
+export declare function readBuildRunState(projectRoot: string): Promise<BuildRunState>;
+/**
+ * One sentence naming why the bundle may be missing, or undefined when
+ * there is no record to go on.
+ *
+ * @param state - From {@link readBuildRunState}
+ */
+export declare function describeBuildRunState(state: BuildRunState): string | undefined;
+export {};

package/dist/src/core/build-run-record.js

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * A record of the mach build in flight, kept in `.fireforge/build-run.json`
+ * so any session on the checkout can see why the bundle is missing.
+ *
+ * An interrupted `fireforge build` (a killed peer session, a closed
+ * terminal) can leave `dist/<App>.app/Contents/MacOS/` without its
+ * executable. Every later `fireforge test`, in every session, then failed
+ * at launch with nothing saying a build had died there, and the sessions
+ * that had not run the build had no way to find out.
+ *
+ * The record is written when a protected mach build starts and removed when
+ * it succeeds. A failed build leaves it with `status: "failed"` and the exit
+ * code. A build that never reached either end, because its process died,
+ * leaves `status: "running"` with a PID that no longer exists, which is how
+ * an interrupted run is recognized. The next build that runs to the end
+ * replaces whatever was there.
+ *
+ * Best-effort throughout: a build never fails because its record could not
+ * be written, and an unreadable record reads as "no record".
+ */
+import { readFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { toError } from '../utils/errors.js';
+import { writeFileAtomic } from '../utils/fs.js';
+import { verbose } from '../utils/logger.js';
+import { FIREFORGE_DIR } from './config-paths.js';
+import { isLockOwnerAlive, readProcessStartTick } from './file-lock-owner.js';
+/** File name of the record under `.fireforge/`. */
+const BUILD_RUN_RECORD = 'build-run.json';
+function recordPath(projectRoot) {
+    return join(projectRoot, FIREFORGE_DIR, BUILD_RUN_RECORD);
+}
+async function writeRecord(projectRoot, record) {
+    try {
+        await writeFileAtomic(recordPath(projectRoot), `${JSON.stringify(record, null, 2)}\n`);
+    }
+    catch (error) {
+        verbose(`Build run record not written: ${toError(error).message}`);
+    }
+}
+/**
+ * Runs a mach build with its run record maintained around it. The record
+ * is removed on a zero exit and kept as `failed` on a non-zero exit or a
+ * throw, so only a build whose process died mid-run is left `running`.
+ *
+ * @param projectRoot - Project root holding `.fireforge/`
+ * @param machCommand - The mach command being run
+ * @param build - The build itself
+ * @returns Whatever the build returned
+ */
+export async function withBuildRunRecord(projectRoot, machCommand, build) {
+    const startTick = readProcessStartTick(process.pid);
+    const started = {
+        status: 'running',
+        pid: process.pid,
+        ...(startTick !== undefined ? { startTick } : {}),
+        command: ['fireforge', ...process.argv.slice(2)].join(' '),
+        machCommand,
+        startedAt: new Date().toISOString(),
+    };
+    await writeRecord(projectRoot, started);
+    let result;
+    try {
+        result = await build();
+    }
+    catch (error) {
+        await writeRecord(projectRoot, {
+            ...started,
+            status: 'failed',
+            endedAt: new Date().toISOString(),
+        });
+        throw error;
+    }
+    if (result.exitCode === 0) {
+        await rm(recordPath(projectRoot), { force: true }).catch(() => undefined);
+    }
+    else {
+        await writeRecord(projectRoot, {
+            ...started,
+            status: 'failed',
+            endedAt: new Date().toISOString(),
+            exitCode: result.exitCode,
+        });
+    }
+    return result;
+}
+/**
+ * Reads the last build's record and decides whether its process is still
+ * running.
+ *
+ * @param projectRoot - Project root holding `.fireforge/`
+ */
+export async function readBuildRunState(projectRoot) {
+    let record;
+    try {
+        record = JSON.parse(await readFile(recordPath(projectRoot), 'utf8'));
+    }
+    catch {
+        return { kind: 'none' };
+    }
+    if (typeof record.pid !== 'number' || typeof record.startedAt !== 'string') {
+        return { kind: 'none' };
+    }
+    if (record.status === 'failed')
+        return { kind: 'failed', record };
+    return {
+        kind: isLockOwnerAlive({ pid: record.pid, startTick: record.startTick })
+            ? 'running'
+            : 'interrupted',
+        record,
+    };
+}
+/**
+ * One sentence naming why the bundle may be missing, or undefined when
+ * there is no record to go on.
+ *
+ * @param state - From {@link readBuildRunState}
+ */
+export function describeBuildRunState(state) {
+    if (state.kind === 'none')
+        return undefined;
+    const { record } = state;
+    const who = `"${record.command}" (${record.machCommand}, PID ${record.pid}, started ${record.startedAt})`;
+    switch (state.kind) {
+        case 'running':
+            return `A build is running right now: ${who}. The bundle is incomplete until it finishes.`;
+        case 'interrupted':
+            return (`The last build never finished: ${who} is gone without recording an end, so it was ` +
+                'interrupted (killed, or its terminal closed) part-way, which leaves the bundle without ' +
+                'its executable.');
+        case 'failed':
+            return (`The last build failed: ${who} ended ${record.endedAt ?? 'at an unrecorded time'}` +
+                `${record.exitCode !== undefined ? ` with exit code ${record.exitCode}` : ''}.`);
+    }
+}

package/dist/src/core/checkjs-support-heads.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Unowned support heads for the named-file checkJs pass of `test --build`.
+ *
+ * Each named test is checked as its own program: the test plus the
+ * patch-owned `head*.js` beside it. A suite moved onto a NEW support head
+ * (`head_world_page.js`, loaded with `loadSubScript`) cannot be proven
+ * before that head is exported, because the head is in no patch: every kit
+ * name reads as "Cannot find name" and the run is refused at preflight,
+ * with the generic hint, which offers the shim as a remedy.
+ *
+ * So an unowned same-directory `head*.js` joins the pass when a named test
+ * loads it with `loadSubScript` or a manifest beside it lists it in
+ * `support-files`, which are the two ways the harness itself would bring
+ * it into the test's scope. The operator is told it is unowned and how to
+ * adopt it, as for the `head.js` companions in
+ * `patch-lint-unmanaged-companion.ts`.
+ */
+/** A same-directory head no patch owns, and why the pass includes it. */
+export interface UnownedSupportHead {
+    /** Engine-relative path of the head. */
+    file: string;
+    /** What brings it into the test's scope. */
+    reason: string;
+}
+/**
+ * Finds the unowned same-directory `head*.js` files the named tests bring
+ * into scope.
+ *
+ * @param engineDir - Absolute engine directory
+ * @param selected - Engine-relative named test files
+ * @param owned - Every file the pass already includes
+ */
+export declare function findUnownedSupportHeads(engineDir: string, selected: Iterable<string>, owned: ReadonlySet<string>): Promise<UnownedSupportHead[]>;
+/**
+ * The notice for an included unowned head: the ownership fact, the
+ * adoption command, and an explicit "not the shim", for the same reason
+ * `formatUnmanagedCompanionHint` gives.
+ *
+ * @param head - From {@link findUnownedSupportHeads}
+ */
+export declare function formatUnownedSupportHeadNotice(head: UnownedSupportHead): string;

package/dist/src/core/checkjs-support-heads.js

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Unowned support heads for the named-file checkJs pass of `test --build`.
+ *
+ * Each named test is checked as its own program: the test plus the
+ * patch-owned `head*.js` beside it. A suite moved onto a NEW support head
+ * (`head_world_page.js`, loaded with `loadSubScript`) cannot be proven
+ * before that head is exported, because the head is in no patch: every kit
+ * name reads as "Cannot find name" and the run is refused at preflight,
+ * with the generic hint, which offers the shim as a remedy.
+ *
+ * So an unowned same-directory `head*.js` joins the pass when a named test
+ * loads it with `loadSubScript` or a manifest beside it lists it in
+ * `support-files`, which are the two ways the harness itself would bring
+ * it into the test's scope. The operator is told it is unowned and how to
+ * adopt it, as for the `head.js` companions in
+ * `patch-lint-unmanaged-companion.ts`.
+ */
+import { readdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { buildSupportFileMatcher, extractSupportFileEntries, } from './patch-lint-forward-registration.js';
+import { findLoadSubScriptTargets } from './patch-lint-unmanaged-companion.js';
+const HEAD_BASENAME_PATTERN = /^head(?:_.*)?\.js$/;
+const TEST_MANIFEST_PATTERN = /^(?:xpcshell|mochitest|browser|chrome|a11y)\.(?:toml|ini)$/;
+async function readOrUndefined(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Why `head` is in scope for the named tests of its directory, if it is. */
+async function findInclusionReason(engineDir, dir, head, context) {
+    const headName = head.slice(dir.length);
+    for (const test of context.tests) {
+        const source = await readOrUndefined(join(engineDir, test));
+        if (source === undefined)
+            continue;
+        const loads = findLoadSubScriptTargets(source).some((target) => target.slice(target.lastIndexOf('/') + 1) === headName);
+        if (loads)
+            return `${test} loads it with loadSubScript`;
+    }
+    for (const manifest of context.manifests) {
+        const source = await readOrUndefined(join(engineDir, manifest));
+        if (source === undefined)
+            continue;
+        const listed = extractSupportFileEntries(source).some(({ entry }) => buildSupportFileMatcher(manifest, entry)?.(head) === true);
+        if (listed)
+            return `${manifest} lists it in support-files`;
+    }
+    return undefined;
+}
+/**
+ * Finds the unowned same-directory `head*.js` files the named tests bring
+ * into scope.
+ *
+ * @param engineDir - Absolute engine directory
+ * @param selected - Engine-relative named test files
+ * @param owned - Every file the pass already includes
+ */
+export async function findUnownedSupportHeads(engineDir, selected, owned) {
+    const testsByDir = new Map();
+    for (const test of selected) {
+        const dir = test.slice(0, test.lastIndexOf('/') + 1);
+        testsByDir.set(dir, [...(testsByDir.get(dir) ?? []), test]);
+    }
+    const heads = [];
+    for (const [dir, tests] of testsByDir) {
+        let names;
+        try {
+            names = (await readdir(join(engineDir, dir))).sort();
+        }
+        catch {
+            continue;
+        }
+        const manifests = names
+            .filter((name) => TEST_MANIFEST_PATTERN.test(name))
+            .map((name) => `${dir}${name}`);
+        const candidates = names
+            .filter((name) => HEAD_BASENAME_PATTERN.test(name))
+            .map((name) => `${dir}${name}`)
+            .filter((file) => !owned.has(file));
+        for (const file of candidates) {
+            const reason = await findInclusionReason(engineDir, dir, file, { tests, manifests });
+            if (reason !== undefined)
+                heads.push({ file, reason });
+        }
+    }
+    return heads;
+}
+/**
+ * The notice for an included unowned head: the ownership fact, the
+ * adoption command, and an explicit "not the shim", for the same reason
+ * `formatUnmanagedCompanionHint` gives.
+ *
+ * @param head - From {@link findUnownedSupportHeads}
+ */
+export function formatUnownedSupportHeadNotice(head) {
+    return (`${head.file} is in no patch yet; the pass includes it because ${head.reason}. ` +
+        `Adopt it with "fireforge re-export <patch> --scan --scan-file ${head.file}" before ` +
+        'export. Do NOT add its globals to the test shim: that would hide a genuinely missing ' +
+        'helper once the head is exported.');
+}

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

@@ -5,9 +5,9 @@ import type { ProjectPaths } from '../types/config.js';
 /** Name of the fireforge data directory */
 export declare const FIREFORGE_DIR = ".fireforge";
 /** 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", "buildAudit", "test", "externalToolchains", "license", "wire", "patchLint", "patchPolicy", "typecheck", "markerComment"];
+export declare const SUPPORTED_CONFIG_ROOT_KEYS: readonly ["name", "vendor", "appId", "binaryName", "firefox", "build", "buildAudit", "test", "history", "externalToolchains", "license", "wire", "patchLint", "patchPolicy", "typecheck", "markerComment", "check"];
 /** 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", "firefox.candidate", "firefox.allowUnverifiedDownload", "build", "build.jobs", "test", "test.canaryPath", "test.canaryTimeoutSeconds", "test.reapOrphans", "externalToolchains", "wire", "wire.subscriptDir", "patchLint", "patchLint.checkJs", "patchLint.checkJsStrict", "patchLint.checkJsCompilerOptions", "patchLint.checkJsExtraShim", "patchLint.checkJsTestFiles", "patchLint.checkJsTestShim", "patchLint.rawColorAllowlist", "patchLint.jsdocClassMethods", "patchLint.testAssertionFloor", "patchLint.chromeScriptJsDoc", "patchLint.forwardRegistration", "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", "firefox.candidate", "firefox.allowUnverifiedDownload", "build", "build.jobs", "test", "test.canaryPath", "test.canaryTimeoutSeconds", "test.reapOrphans", "test.mochitestPorts", "history", "history.path", "externalToolchains", "wire", "wire.subscriptDir", "patchLint", "patchLint.checkJs", "patchLint.checkJsStrict", "patchLint.checkJsCompilerOptions", "patchLint.checkJsExtraShim", "patchLint.checkJsTestFiles", "patchLint.checkJsTestShim", "patchLint.rawColorAllowlist", "patchLint.jsdocClassMethods", "patchLint.testAssertionFloor", "patchLint.chromeScriptJsDoc", "patchLint.forwardRegistration", "patchLint.fileSizeMetric", "patchLint.patchSizeMetric", "patchPolicy", "typecheck", "typecheck.projects", "typecheck.extraShim", "markerComment", "check"];
 /**
  * Gets all project paths based on a root directory.
  * @param root - Root directory of the project

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

@@ -27,6 +27,7 @@ export const SUPPORTED_CONFIG_ROOT_KEYS = [
     'build',
     'buildAudit',
     'test',
+    'history',
     'externalToolchains',
     'license',
     'wire',
@@ -34,6 +35,7 @@ export const SUPPORTED_CONFIG_ROOT_KEYS = [
     'patchPolicy',
     'typecheck',
     'markerComment',
+    'check',
 ];
 /** Supported config paths that can be read or set without --force. */
 export const SUPPORTED_CONFIG_PATHS = [
@@ -54,6 +56,9 @@ export const SUPPORTED_CONFIG_PATHS = [
     'test.canaryPath',
     'test.canaryTimeoutSeconds',
     'test.reapOrphans',
+    'test.mochitestPorts',
+    'history',
+    'history.path',
     'externalToolchains',
     'wire',
     'wire.subscriptDir',
@@ -69,11 +74,14 @@ export const SUPPORTED_CONFIG_PATHS = [
     'patchLint.testAssertionFloor',
     'patchLint.chromeScriptJsDoc',
     'patchLint.forwardRegistration',
+    'patchLint.fileSizeMetric',
+    'patchLint.patchSizeMetric',
     'patchPolicy',
     'typecheck',
     'typecheck.projects',
     'typecheck.extraShim',
     'markerComment',
+    'check',
 ];
 /**
  * Gets all project paths based on a root directory.

package/dist/src/core/config-validate-check.d.ts

@@ -0,0 +1,8 @@
+import { type CheckConfig } from '../types/config.js';
+/**
+ * Parses the `check` block.
+ *
+ * @param raw - The raw `check` value from fireforge.json
+ * @returns The validated block
+ */
+export declare function parseCheckConfig(raw: unknown): CheckConfig;

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

@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Validation for the `check` block (`fireforge check`).
+ *
+ * Split out of `config-validate.ts`, which is at its per-file line budget,
+ * following the `config-validate-build-audit.ts` precedent. Unknown keys are
+ * refused: a misspelt `extraSteps` would otherwise drop a project audit from
+ * the gate without a word.
+ */
+import { ConfigError } from '../errors/config.js';
+import { CHECK_BUILTIN_STEPS, } from '../types/config.js';
+import { isContainedRelativePath } from '../utils/paths.js';
+import { isObject } from '../utils/validation.js';
+const STEP_NAME_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+function assertKnownKeys(raw, field, known) {
+    for (const key of Object.keys(raw)) {
+        if (!known.includes(key)) {
+            throw new ConfigError(`Config field "${field}" has unknown key "${key}"`);
+        }
+    }
+}
+function parseStringList(raw, field) {
+    if (!Array.isArray(raw) || raw.some((entry) => typeof entry !== 'string' || entry === '')) {
+        throw new ConfigError(`Config field "${field}" must be an array of non-empty strings`);
+    }
+    return raw;
+}
+function parseNonNegativeInteger(raw, field) {
+    if (typeof raw !== 'number' || !Number.isInteger(raw) || raw < 0) {
+        throw new ConfigError(`Config field "${field}" must be a non-negative integer`);
+    }
+    return raw;
+}
+function isBuiltinStep(value) {
+    return CHECK_BUILTIN_STEPS.includes(value);
+}
+function parseSkip(raw) {
+    const skip = parseStringList(raw, 'check.skip');
+    for (const entry of skip) {
+        if (!isBuiltinStep(entry)) {
+            throw new ConfigError(`Config field "check.skip" names unknown step "${entry}". Valid: ${CHECK_BUILTIN_STEPS.join(', ')}`);
+        }
+    }
+    return skip;
+}
+function parseStatusPolicy(raw) {
+    if (!isObject(raw))
+        throw new ConfigError('Config field "check.status" must be a plain object');
+    assertKnownKeys(raw, 'check.status', ['failOn', 'allow', 'failOnUnknown']);
+    const out = {};
+    if (raw['failOn'] !== undefined)
+        out.failOn = parseStringList(raw['failOn'], 'check.status.failOn');
+    if (raw['allow'] !== undefined)
+        out.allow = parseStringList(raw['allow'], 'check.status.allow');
+    if (raw['failOnUnknown'] !== undefined) {
+        if (typeof raw['failOnUnknown'] !== 'boolean') {
+            throw new ConfigError('Config field "check.status.failOnUnknown" must be a boolean');
+        }
+        out.failOnUnknown = raw['failOnUnknown'];
+    }
+    return out;
+}
+function parseMaxWarnings(raw) {
+    if (!isObject(raw)) {
+        throw new ConfigError('Config field "check.maxWarnings" must be a plain object');
+    }
+    assertKnownKeys(raw, 'check.maxWarnings', ['lint', 'furnace']);
+    const out = {};
+    if (raw['lint'] !== undefined) {
+        out.lint = parseNonNegativeInteger(raw['lint'], 'check.maxWarnings.lint');
+    }
+    if (raw['furnace'] !== undefined) {
+        out.furnace = parseNonNegativeInteger(raw['furnace'], 'check.maxWarnings.furnace');
+    }
+    return out;
+}
+function parseExtraStep(raw, field) {
+    if (!isObject(raw)) {
+        throw new ConfigError(`Config field "${field}" must be a plain object with "name" and "command"`);
+    }
+    assertKnownKeys(raw, field, ['name', 'command', 'cwd', 'timeout']);
+    const name = raw['name'];
+    if (typeof name !== 'string' || !STEP_NAME_PATTERN.test(name)) {
+        throw new ConfigError(`Config field "${field}.name" must be lowercase letters, digits and dashes (e.g. "policy-audit")`);
+    }
+    if (isBuiltinStep(name)) {
+        throw new ConfigError(`Config field "${field}.name" "${name}" is a built-in step name`);
+    }
+    const command = raw['command'];
+    if (typeof command !== 'string' || command.trim() === '') {
+        throw new ConfigError(`Config field "${field}.command" must be a non-empty string`);
+    }
+    const step = { name, command };
+    if (raw['cwd'] !== undefined) {
+        const cwd = raw['cwd'];
+        if (typeof cwd !== 'string' || cwd.trim() === '' || !isContainedRelativePath(cwd)) {
+            throw new ConfigError(`Config field "${field}.cwd" must be a project-relative path`);
+        }
+        step.cwd = cwd;
+    }
+    if (raw['timeout'] !== undefined) {
+        const timeout = parseNonNegativeInteger(raw['timeout'], `${field}.timeout`);
+        if (timeout === 0) {
+            throw new ConfigError(`Config field "${field}.timeout" must be a positive number of seconds`);
+        }
+        step.timeout = timeout;
+    }
+    return step;
+}
+function parseExtraSteps(raw) {
+    if (!Array.isArray(raw))
+        throw new ConfigError('Config field "check.extraSteps" must be an array');
+    const steps = raw.map((entry, index) => parseExtraStep(entry, `check.extraSteps[${String(index)}]`));
+    const seen = new Set();
+    for (const step of steps) {
+        if (seen.has(step.name)) {
+            throw new ConfigError(`Config field "check.extraSteps" repeats the step name "${step.name}"`);
+        }
+        seen.add(step.name);
+    }
+    return steps;
+}
+/**
+ * Parses the `check` block.
+ *
+ * @param raw - The raw `check` value from fireforge.json
+ * @returns The validated block
+ */
+export function parseCheckConfig(raw) {
+    if (!isObject(raw))
+        throw new ConfigError('Config field "check" must be a plain object');
+    assertKnownKeys(raw, 'check', ['skip', 'status', 'maxWarnings', 'extraSteps']);
+    const out = {};
+    if (raw['skip'] !== undefined)
+        out.skip = parseSkip(raw['skip']);
+    if (raw['status'] !== undefined)
+        out.status = parseStatusPolicy(raw['status']);
+    if (raw['maxWarnings'] !== undefined)
+        out.maxWarnings = parseMaxWarnings(raw['maxWarnings']);
+    if (raw['extraSteps'] !== undefined)
+        out.extraSteps = parseExtraSteps(raw['extraSteps']);
+    return out;
+}

package/dist/src/core/config-validate-file-size.d.ts

@@ -1,12 +1,15 @@
 /**
- * Validation for `patchLint.fileSizeThresholds`.
+ * Validation for the size-rule keys of `patchLint`: `fileSizeThresholds`,
+ * `fileSizeMetric`, `patchSizeThresholds`, `patchSizeMetric` and
+ * `patchSizeRegistrationFiles`.
  *
  * Split out of `config-validate.ts`, which is at its per-file line budget.
  */
-import type { PatchLintFileSizeThresholds } from '../types/config.js';
+import type { PatchLintConfig } from '../types/config.js';
 /**
- * Parses the `patchLint.fileSizeThresholds` block. Ordering is validated
- * against the merged triple (overrides on top of the defaults), so setting
- * only `warning` cannot land below the default `notice`.
+ * Parses every size-rule key of the `patchLint` block.
+ *
+ * @param read - Reads one raw `patchLint` field by key
+ * @returns The parsed fields, only those present
  */
-export declare function parsePatchLintFileSizeThresholds(raw: unknown): PatchLintFileSizeThresholds;
+export declare function parsePatchLintSizeFields(read: (key: string) => unknown): Pick<PatchLintConfig, 'fileSizeThresholds' | 'fileSizeMetric' | 'patchSizeThresholds' | 'patchSizeMetric' | 'patchSizeRegistrationFiles'>;