@hominis/fireforge 0.49.2 → 0.51.0

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", "test.lockMode", "test.furnaceApply", "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,11 @@ export const SUPPORTED_CONFIG_PATHS = [
     'test.canaryPath',
     'test.canaryTimeoutSeconds',
     'test.reapOrphans',
+    'test.mochitestPorts',
+    'test.lockMode',
+    'test.furnaceApply',
+    'history',
+    'history.path',
     'externalToolchains',
     'wire',
     'wire.subscriptDir',
@@ -69,11 +76,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,219 @@
+// 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', 'after']);
+    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) {
+        step.timeout = parsePositiveSeconds(raw['timeout'], `${field}.timeout`);
+    }
+    if (raw['after'] !== undefined)
+        step.after = parseStringList(raw['after'], `${field}.after`);
+    return step;
+}
+function parsePositiveSeconds(raw, field) {
+    const seconds = parseNonNegativeInteger(raw, field);
+    if (seconds === 0) {
+        throw new ConfigError(`Config field "${field}" must be a positive number of seconds`);
+    }
+    return seconds;
+}
+/**
+ * Checks every `after` names a known step and the extra steps' ordering
+ * has no cycle: a cycle would leave its steps waiting forever.
+ */
+function assertExtraStepOrdering(steps) {
+    const extras = new Map(steps.map((step) => [step.name, step]));
+    for (const [index, step] of steps.entries()) {
+        for (const dependency of step.after ?? []) {
+            if (dependency === step.name) {
+                throw new ConfigError(`Config field "check.extraSteps[${String(index)}].after" names the step itself`);
+            }
+            if (!isBuiltinStep(dependency) && !extras.has(dependency)) {
+                throw new ConfigError(`Config field "check.extraSteps[${String(index)}].after" names unknown step "${dependency}"`);
+            }
+        }
+    }
+    const state = new Map();
+    const visit = (name, path) => {
+        if (state.get(name) === 'done')
+            return;
+        if (state.get(name) === 'visiting') {
+            throw new ConfigError(`Config field "check.extraSteps" orders its steps in a cycle: ${[...path, name].join(' -> ')}`);
+        }
+        state.set(name, 'visiting');
+        for (const dependency of extras.get(name)?.after ?? []) {
+            if (extras.has(dependency))
+                visit(dependency, [...path, name]);
+        }
+        state.set(name, 'done');
+    };
+    for (const step of steps)
+        visit(step.name, []);
+}
+function parseTimeouts(raw) {
+    if (!isObject(raw))
+        throw new ConfigError('Config field "check.timeouts" must be a plain object');
+    assertKnownKeys(raw, 'check.timeouts', [...CHECK_BUILTIN_STEPS]);
+    const out = {};
+    for (const [name, value] of Object.entries(raw)) {
+        if (isBuiltinStep(name))
+            out[name] = parsePositiveSeconds(value, `check.timeouts.${name}`);
+    }
+    return out;
+}
+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);
+    }
+    assertExtraStepOrdering(steps);
+    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',
+        'timeout',
+        'timeouts',
+        'failOnSkipped',
+        'lintReport',
+    ]);
+    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']);
+    if (raw['timeout'] !== undefined)
+        out.timeout = parsePositiveSeconds(raw['timeout'], 'check.timeout');
+    if (raw['timeouts'] !== undefined)
+        out.timeouts = parseTimeouts(raw['timeouts']);
+    if (raw['failOnSkipped'] !== undefined) {
+        if (typeof raw['failOnSkipped'] !== 'boolean') {
+            throw new ConfigError('Config field "check.failOnSkipped" must be a boolean');
+        }
+        out.failOnSkipped = raw['failOnSkipped'];
+    }
+    if (raw['lintReport'] !== undefined) {
+        const path = raw['lintReport'];
+        if (typeof path !== 'string' || path.trim() === '' || !isContainedRelativePath(path)) {
+            throw new ConfigError('Config field "check.lintReport" must be a project-relative path');
+        }
+        out.lintReport = path;
+    }
+    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'>;

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

@@ -1,12 +1,15 @@
 // SPDX-License-Identifier: EUPL-1.2
 /**
- * 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 { ConfigError } from '../errors/config.js';
 import { isObject } from '../utils/validation.js';
 import { DEFAULT_FILE_SIZE_THRESHOLDS } from './patch-lint-file-size.js';
+import { resolvePatchSizeThresholds, } from './patch-lint-size-thresholds.js';
 /**
  * Parses one `patchLint.fileSizeThresholds.<tier>` triple. Every field is
  * optional and merges over the built-in default. Values must be positive
@@ -39,7 +42,7 @@ function parseFileSizeTier(raw, field) {
  * against the merged triple (overrides on top of the defaults), so setting
  * only `warning` cannot land below the default `notice`.
  */
-export function parsePatchLintFileSizeThresholds(raw) {
+function parsePatchLintFileSizeThresholds(raw) {
     if (!isObject(raw)) {
         throw new ConfigError('Config field "patchLint.fileSizeThresholds" must be a plain object');
     }
@@ -63,3 +66,89 @@ export function parsePatchLintFileSizeThresholds(raw) {
     }
     return out;
 }
+/** Throws unless `merged` is ordered `notice <= warning <= error` (a `null` error is unbounded). */
+function assertOrderedTriple(merged, field) {
+    if (merged.notice > merged.warning || (merged.error !== null && merged.warning > merged.error)) {
+        throw new ConfigError(`Config field "${field}" must satisfy notice <= warning <= error ` +
+            `(resolved: ${merged.notice}/${merged.warning}/${merged.error ?? 'none'})`);
+    }
+}
+/**
+ * Parses one `patchLint.patchSizeThresholds.<tier>` entry: optional
+ * `lines` and `files` triples, each validated against its merged result.
+ */
+function parsePatchSizeTier(raw, tier) {
+    const field = `patchLint.patchSizeThresholds.${tier}`;
+    if (!isObject(raw)) {
+        throw new ConfigError(`Config field "${field}" must be a plain object`);
+    }
+    const out = {};
+    for (const key of Object.keys(raw)) {
+        if (key !== 'lines' && key !== 'files') {
+            throw new ConfigError(`Config field "${field}" has unknown key "${key}"`);
+        }
+        out[key] = parseFileSizeTier(raw[key], `${field}.${key}`);
+    }
+    const merged = resolvePatchSizeThresholds(tier, { [tier]: out });
+    assertOrderedTriple(merged.lines, `${field}.lines`);
+    assertOrderedTriple(merged.files, `${field}.files`);
+    return out;
+}
+/** Parses the `patchLint.patchSizeThresholds` block. */
+function parsePatchLintPatchSizeThresholds(raw) {
+    if (!isObject(raw)) {
+        throw new ConfigError('Config field "patchLint.patchSizeThresholds" must be a plain object');
+    }
+    const out = {};
+    for (const key of Object.keys(raw)) {
+        if (key !== 'general' && key !== 'test' && key !== 'branding') {
+            throw new ConfigError(`Config field "patchLint.patchSizeThresholds" has unknown key "${key}"`);
+        }
+        out[key] = parsePatchSizeTier(raw[key], key);
+    }
+    return out;
+}
+/** Parses an enum-valued `patchLint` key, naming the allowed values on failure. */
+function parseEnum(raw, field, values) {
+    if (typeof raw !== 'string' || !values.includes(raw)) {
+        throw new ConfigError(`Config field "${field}" must be one of: ${values.join(', ')}`);
+    }
+    return raw;
+}
+/**
+ * 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 function parsePatchLintSizeFields(read) {
+    const out = {};
+    const fileSizeThresholds = read('fileSizeThresholds');
+    if (fileSizeThresholds !== undefined) {
+        out.fileSizeThresholds = parsePatchLintFileSizeThresholds(fileSizeThresholds);
+    }
+    const fileSizeMetric = read('fileSizeMetric');
+    if (fileSizeMetric !== undefined) {
+        out.fileSizeMetric = parseEnum(fileSizeMetric, 'patchLint.fileSizeMetric', ['raw', 'code']);
+    }
+    const patchSizeThresholds = read('patchSizeThresholds');
+    if (patchSizeThresholds !== undefined) {
+        out.patchSizeThresholds = parsePatchLintPatchSizeThresholds(patchSizeThresholds);
+    }
+    const patchSizeMetric = read('patchSizeMetric');
+    if (patchSizeMetric !== undefined) {
+        out.patchSizeMetric = parseEnum(patchSizeMetric, 'patchLint.patchSizeMetric', [
+            'diff',
+            'addedCode',
+        ]);
+    }
+    const registration = read('patchSizeRegistrationFiles');
+    if (registration !== undefined) {
+        if (!Array.isArray(registration) ||
+            registration.some((v) => typeof v !== 'string' || v.trim() === '')) {
+            throw new ConfigError('Config field "patchLint.patchSizeRegistrationFiles" must be an array of non-empty strings');
+        }
+        out.patchSizeRegistrationFiles = registration;
+    }
+    return out;
+}

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

@@ -0,0 +1,11 @@
+import type { FireForgeConfig } from '../types/config.js';
+import type { ParsedRecord } from '../utils/parse.js';
+/**
+ * Whether a `history.path` value is usable: a non-empty, project-relative
+ * path that stays inside the project and names a file, not the root.
+ * Shared with the history writer, which reads the raw config and must agree
+ * with validation about what it may write to.
+ */
+export declare function isValidHistoryPath(value: unknown): value is string;
+/** Parses the optional `history` block. */
+export declare function parseHistoryBlock(rec: ParsedRecord, config: FireForgeConfig): void;

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

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: EUPL-1.2
+import { ConfigError } from '../errors/config.js';
+import { isContainedRelativePath } from '../utils/paths.js';
+/**
+ * Whether a `history.path` value is usable: a non-empty, project-relative
+ * path that stays inside the project and names a file, not the root.
+ * Shared with the history writer, which reads the raw config and must agree
+ * with validation about what it may write to.
+ */
+export function isValidHistoryPath(value) {
+    return (typeof value === 'string' &&
+        value.trim() !== '' &&
+        value.trim() !== '.' &&
+        !/[\n\r]/.test(value) &&
+        isContainedRelativePath(value));
+}
+/** Parses the optional `history` block. */
+export function parseHistoryBlock(rec, config) {
+    const raw = rec.raw('history');
+    if (raw === undefined)
+        return;
+    let historyRec;
+    try {
+        historyRec = rec.object('history');
+    }
+    catch {
+        throw new ConfigError('Config field "history" must be an object');
+    }
+    const out = {};
+    const path = historyRec.raw('path');
+    if (path !== undefined) {
+        if (!isValidHistoryPath(path)) {
+            throw new ConfigError('Config field "history.path" must be a project-relative file path inside the project');
+        }
+        out.path = path;
+    }
+    config.history = out;
+}