@hominis/fireforge 0.49.1 → 0.50.0

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;
+}

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

@@ -121,6 +121,105 @@ function assertPolicyRangesDoNotOverlap(ranges, label) {
         }
     }
 }
+function parseNonEmptyString(raw, label) {
+    if (typeof raw !== 'string' || raw.trim() === '') {
+        throw new ConfigError(`Config field "${label}" must be a non-empty string`);
+    }
+    return raw;
+}
+function parseGlobList(raw, label) {
+    if (!Array.isArray(raw) || raw.length === 0) {
+        throw new ConfigError(`Config field "${label}" must be a non-empty array of path globs`);
+    }
+    return raw.map((entry, index) => parseNonEmptyString(entry, `${label}[${index}]`));
+}
+function parseUpstreamAllowEntry(raw, label, defaultMarker) {
+    if (typeof raw === 'string')
+        return parseNonEmptyString(raw, label);
+    let rec;
+    try {
+        rec = parseObject(raw, label);
+    }
+    catch {
+        throw new ConfigError(`Config field "${label}" must be a path glob or an object`);
+    }
+    const entry = {
+        path: parseNonEmptyString(rec.raw('path'), `${label}.path`),
+    };
+    const addOnly = rec.raw('addOnly');
+    if (addOnly !== undefined) {
+        if (typeof addOnly !== 'boolean') {
+            throw new ConfigError(`Config field "${label}.addOnly" must be a boolean`);
+        }
+        entry.addOnly = addOnly;
+    }
+    const marker = rec.raw('marker');
+    if (marker !== undefined)
+        entry.marker = parseNonEmptyString(marker, `${label}.marker`);
+    if (entry.addOnly === true && entry.marker === undefined && defaultMarker === undefined) {
+        throw new ConfigError(`Config field "${label}" sets addOnly but no marker: set "${label}.marker" or "patchPolicy.addOnlyMarker"`);
+    }
+    return entry;
+}
+function parseScopeRule(raw, label) {
+    let rec;
+    try {
+        rec = parseObject(raw, label);
+    }
+    catch {
+        throw new ConfigError(`Config field "${label}" must be an object`);
+    }
+    const rule = { files: parseGlobList(rec.raw('files'), `${label}.files`) };
+    const category = rec.raw('category');
+    if (category !== undefined) {
+        rule.category = parsePatchPolicyCategory(category, `${label}.category`);
+    }
+    const filenamePattern = optionalConfigString(rec, 'filenamePattern', `${label}.filenamePattern`);
+    if (filenamePattern !== undefined) {
+        try {
+            new RegExp(filenamePattern);
+        }
+        catch (error) {
+            throw new ConfigError(`Config field "${label}.filenamePattern" must be a valid regular expression: ${toError(error).message}`);
+        }
+        rule.filenamePattern = filenamePattern;
+    }
+    if (rule.category === undefined && rule.filenamePattern === undefined) {
+        throw new ConfigError(`Config field "${label}" must set "category" or "filenamePattern" to select the patches it scopes`);
+    }
+    return rule;
+}
+/**
+ * Parses the registration-only policy fields: `upstreamAllowlist`,
+ * `addOnlyMarker`, `scopeRules` and `verifyDocumentPaths`. All opt-in.
+ */
+function parsePatchPolicyContentRules(rec, out) {
+    const addOnlyMarker = rec.raw('addOnlyMarker');
+    if (addOnlyMarker !== undefined) {
+        out.addOnlyMarker = parseNonEmptyString(addOnlyMarker, 'patchPolicy.addOnlyMarker');
+    }
+    const allowlist = rec.raw('upstreamAllowlist');
+    if (allowlist !== undefined) {
+        if (!Array.isArray(allowlist)) {
+            throw new ConfigError('Config field "patchPolicy.upstreamAllowlist" must be an array');
+        }
+        out.upstreamAllowlist = allowlist.map((entry, index) => parseUpstreamAllowEntry(entry, `patchPolicy.upstreamAllowlist[${index}]`, out.addOnlyMarker));
+    }
+    const scopeRules = rec.raw('scopeRules');
+    if (scopeRules !== undefined) {
+        if (!Array.isArray(scopeRules)) {
+            throw new ConfigError('Config field "patchPolicy.scopeRules" must be an array');
+        }
+        out.scopeRules = scopeRules.map((entry, index) => parseScopeRule(entry, `patchPolicy.scopeRules[${index}]`));
+    }
+    const verifyDocumentPaths = rec.raw('verifyDocumentPaths');
+    if (verifyDocumentPaths !== undefined) {
+        if (typeof verifyDocumentPaths !== 'boolean') {
+            throw new ConfigError('Config field "patchPolicy.verifyDocumentPaths" must be a boolean');
+        }
+        out.verifyDocumentPaths = verifyDocumentPaths;
+    }
+}
 /** Parses and validates the optional patch policy config block. */
 export function parsePatchPolicyBlock(rec) {
     const out = { ranges: [] };
@@ -170,5 +269,6 @@ export function parsePatchPolicyBlock(rec) {
         out.reservedRanges = reservedRangesRaw.map((entry, index) => parsePatchPolicyReservedRange(entry, `patchPolicy.reservedRanges[${index}]`));
         assertPolicyRangesDoNotOverlap(out.reservedRanges, 'patchPolicy.reservedRanges');
     }
+    parsePatchPolicyContentRules(rec, out);
     return out;
 }

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

@@ -52,6 +52,13 @@ export function parseTestBlock(rec, config) {
         }
         out.reapOrphans = reapOrphans;
     }
+    const mochitestPorts = testRec.raw('mochitestPorts');
+    if (mochitestPorts !== undefined) {
+        if (mochitestPorts !== 'fixed' && mochitestPorts !== 'auto') {
+            throw new ConfigError('Config field "test.mochitestPorts" must be "fixed" or "auto"');
+        }
+        out.mochitestPorts = mochitestPorts;
+    }
     config.test = out;
 }
 /** Parses optional project-specific external toolchain doctor probes. */

package/dist/src/core/config-validate-token-scales.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Validation for `fireforge.json#patchLint.tokenScales`.
+ */
+import type { PatchLintTokenScale } from '../types/config.js';
+/** Parses and validates `patchLint.tokenScales`. */
+export declare function parsePatchLintTokenScales(raw: unknown): PatchLintTokenScale[];

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

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Validation for `fireforge.json#patchLint.tokenScales`.
+ */
+import { ConfigError } from '../errors/config.js';
+import { parseObject } from '../utils/parse.js';
+function parseNames(raw, label, required) {
+    if (raw === undefined && !required)
+        return undefined;
+    if (!Array.isArray(raw) ||
+        (required && raw.length === 0) ||
+        raw.some((value) => typeof value !== 'string' || value.trim() === '')) {
+        throw new ConfigError(`Config field "${label}" must be ${required ? 'a non-empty' : 'an'} array of non-empty strings`);
+    }
+    return raw;
+}
+function parseTokenScale(raw, label) {
+    let rec;
+    try {
+        rec = parseObject(raw, label);
+    }
+    catch {
+        throw new ConfigError(`Config field "${label}" must be an object`);
+    }
+    const properties = parseNames(rec.raw('properties'), `${label}.properties`, true) ?? [];
+    const prefix = rec.raw('prefix');
+    if (typeof prefix !== 'string' || !/^--[\w-]+$/.test(prefix)) {
+        throw new ConfigError(`Config field "${label}.prefix" must be a custom-property prefix such as "--mybrowser-space-"`);
+    }
+    const scale = { properties, prefix };
+    const allowLiterals = parseNames(rec.raw('allowLiterals'), `${label}.allowLiterals`, false);
+    if (allowLiterals !== undefined)
+        scale.allowLiterals = allowLiterals;
+    const allow = parseNames(rec.raw('allow'), `${label}.allow`, false);
+    if (allow !== undefined) {
+        const malformed = allow.find((name) => !name.startsWith('--'));
+        if (malformed !== undefined) {
+            throw new ConfigError(`Config field "${label}.allow" entries must be custom-property names starting with "--" (got "${malformed}")`);
+        }
+        scale.allow = allow;
+    }
+    return scale;
+}
+/** Parses and validates `patchLint.tokenScales`. */
+export function parsePatchLintTokenScales(raw) {
+    if (!Array.isArray(raw)) {
+        throw new ConfigError('Config field "patchLint.tokenScales" must be an array');
+    }
+    return raw.map((entry, index) => parseTokenScale(entry, `patchLint.tokenScales[${index}]`));
+}

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

@@ -9,9 +9,12 @@ import { isContainedRelativePath, isExplicitAbsolutePath } from '../utils/paths.
 import { describeProductVersionIncompatibility, FIREFOX_PRODUCTS, isObject, isValidAppId, isValidFirefoxCandidate, isValidFirefoxProduct, isValidFirefoxVersion, isValidProjectLicense, PROJECT_LICENSES, } from '../utils/validation.js';
 import { SUPPORTED_CONFIG_ROOT_KEYS } from './config-paths.js';
 import { parseBuildAuditConfig } from './config-validate-build-audit.js';
-import { parsePatchLintFileSizeThresholds } from './config-validate-file-size.js';
+import { parseCheckConfig } from './config-validate-check.js';
+import { parsePatchLintSizeFields } from './config-validate-file-size.js';
+import { parseHistoryBlock } from './config-validate-history.js';
 import { parsePatchPolicyBlock } from './config-validate-patch-policy.js';
 import { parseExternalToolchainsBlock, parseTestBlock } from './config-validate-test-toolchains.js';
+import { parsePatchLintTokenScales } from './config-validate-token-scales.js';
 /**
  * Parses and validates the four required identity fields (`name`,
  * `vendor`, `appId`, `binaryName`): all non-empty strings, with
@@ -167,6 +170,7 @@ export function validateConfig(data) {
         config.buildAudit = parseBuildAuditConfig(buildAuditRaw);
     }
     parseTestBlock(rec, config);
+    parseHistoryBlock(rec, config);
     parseExternalToolchainsBlock(rec, config);
     parseWireBlock(rec, config);
     parseLicenseField(rec, config);
@@ -190,6 +194,11 @@ export function validateConfig(data) {
     if (typecheckRec) {
         config.typecheck = parseTypecheckBlock(typecheckRec);
     }
+    // `fireforge check` policy and project steps.
+    const checkRaw = rec.raw('check');
+    if (checkRaw !== undefined) {
+        config.check = parseCheckConfig(checkRaw);
+    }
     // Warn on unknown root keys
     const knownRootKeys = new Set(SUPPORTED_CONFIG_ROOT_KEYS);
     for (const key of rec.keys()) {
@@ -372,10 +381,7 @@ function parsePatchLintBlock(rec) {
         }
         out.rawColorAllowlist = rawColorAllowlist;
     }
-    const fileSizeThresholds = rec.raw('fileSizeThresholds');
-    if (fileSizeThresholds !== undefined) {
-        out.fileSizeThresholds = parsePatchLintFileSizeThresholds(fileSizeThresholds);
-    }
+    Object.assign(out, parsePatchLintSizeFields((key) => rec.raw(key)));
     const forwardRegistration = rec.raw('forwardRegistration');
     if (forwardRegistration !== undefined) {
         if (forwardRegistration !== 'support-files' && forwardRegistration !== 'extended') {
@@ -383,6 +389,9 @@ function parsePatchLintBlock(rec) {
         }
         out.forwardRegistration = forwardRegistration;
     }
+    const tokenScales = rec.raw('tokenScales');
+    if (tokenScales !== undefined)
+        out.tokenScales = parsePatchLintTokenScales(tokenScales);
     for (const key of PATCH_LINT_SEVERITY_GATE_KEYS) {
         const gate = parseSeverityGate(rec.raw(key), `patchLint.${key}`);
         if (gate !== undefined)

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

@@ -54,6 +54,11 @@ export declare function writeConfig(root: string, config: FireForgeConfig): Prom
  * This is used by CLI `config --force`, where callers may intentionally write
  * keys or value shapes outside the validated FireForgeConfig schema.
  *
+ * An existing file is edited in place: only the values that differ from the
+ * document on disk are rewritten, so a one-key change keeps the file's
+ * formatting (compact objects and arrays, indentation, key order) and stays
+ * a one-hunk diff. A missing or unparseable file is written in full.
+ *
  * Individual writes are atomic via {@link writeJson} (temp file + rename),
  * but atomicity alone does not prevent lost updates across concurrent
  * writers: each writer reads an old copy, mutates its own in-memory view,

package/dist/src/core/config.js

@@ -16,6 +16,7 @@ import { isObject } from '../utils/validation.js';
 import { getProjectPaths } from './config-paths.js';
 import { validateConfig } from './config-validate.js';
 import { createSiblingLockPath, withFileLock } from './file-lock.js';
+import { rewriteJsonPreservingFormat } from './json-preserving-edit.js';
 // ---- re-exports ----
 export { mutateConfig } from './config-mutate.js';
 export { FIREFORGE_DIR, getProjectPaths, SUPPORTED_CONFIG_PATHS, SUPPORTED_CONFIG_ROOT_KEYS, } from './config-paths.js';
@@ -109,6 +110,11 @@ export async function writeConfig(root, config) {
  * This is used by CLI `config --force`, where callers may intentionally write
  * keys or value shapes outside the validated FireForgeConfig schema.
  *
+ * An existing file is edited in place: only the values that differ from the
+ * document on disk are rewritten, so a one-key change keeps the file's
+ * formatting (compact objects and arrays, indentation, key order) and stays
+ * a one-hunk diff. A missing or unparseable file is written in full.
+ *
  * Individual writes are atomic via {@link writeJson} (temp file + rename),
  * but atomicity alone does not prevent lost updates across concurrent
  * writers: each writer reads an old copy, mutates its own in-memory view,
@@ -119,6 +125,16 @@ export async function writeConfig(root, config) {
  */
 export async function writeConfigDocument(root, config) {
     const paths = getProjectPaths(root);
+    if (await fsUtils.pathExists(paths.config)) {
+        const current = await fsUtils.readText(paths.config);
+        // `FireForgeConfig` is plain parsed-config data, so it is a JSON object.
+        const edited = rewriteJsonPreservingFormat(current, config);
+        if (edited !== undefined) {
+            if (edited !== current)
+                await fsUtils.writeText(paths.config, edited);
+            return;
+        }
+    }
     await fsUtils.writeJson(paths.config, config);
 }
 /**

package/dist/src/core/coverage-dispatch.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Dispatch-time half of per-path coverage. A scoped build that followed a
+ * full build carries the full build's anchor forward instead of collapsing
+ * the claim to its own paths. A requested path outside the scoped list is
+ * then still covered while its own staging inputs are unchanged against
+ * that anchor, and a refusal names the inputs that did change.
+ */
+import type { BuildBaseline } from './build-baseline-types.js';
+/** A requested path no recorded claim covers, with the inputs that explain it. */
+export interface UncoveredRequest {
+    path: string;
+    /** Staging inputs changed since the carried full build. Empty when unknown. */
+    changed: string[];
+}
+/**
+ * Re-checks the paths the scoped list does not cover against the carried
+ * full-build anchor. Returns the paths that stay uncovered.
+ *
+ * @param engineDir - Path to the engine directory
+ * @param baseline - Last successful build's baseline
+ * @param uncovered - Request paths outside the scoped list
+ * @param fullSuite - The sentinel standing for a path-less (full-suite) request
+ */
+export declare function filterByCarriedFullCoverage(engineDir: string, baseline: BuildBaseline | undefined, uncovered: readonly string[], fullSuite: string): Promise<UncoveredRequest[]>;

package/dist/src/core/coverage-dispatch.js

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: EUPL-1.2
+/**
+ * Dispatch-time half of per-path coverage. A scoped build that followed a
+ * full build carries the full build's anchor forward instead of collapsing
+ * the claim to its own paths. A requested path outside the scoped list is
+ * then still covered while its own staging inputs are unchanged against
+ * that anchor, and a refusal names the inputs that did change.
+ */
+import { toError } from '../utils/errors.js';
+import { verbose } from '../utils/logger.js';
+import { collectStagingInputs, findChangedInputs, hashEngineFile, readEngineContentState, } from './coverage-records.js';
+/**
+ * Re-checks the paths the scoped list does not cover against the carried
+ * full-build anchor. Returns the paths that stay uncovered.
+ *
+ * @param engineDir - Path to the engine directory
+ * @param baseline - Last successful build's baseline
+ * @param uncovered - Request paths outside the scoped list
+ * @param fullSuite - The sentinel standing for a path-less (full-suite) request
+ */
+export async function filterByCarriedFullCoverage(engineDir, baseline, uncovered, fullSuite) {
+    const unresolved = uncovered.map((path) => ({ path, changed: [] }));
+    const anchor = baseline?.fullCoverageAnchor;
+    if (anchor === undefined || uncovered.length === 0)
+        return unresolved;
+    if ((await hashEngineFile(engineDir, 'mozconfig')) !== anchor.mozconfigHash)
+        return unresolved;
+    let state;
+    try {
+        state = await readEngineContentState(engineDir);
+    }
+    catch (error) {
+        verbose(`Coverage check: engine state unreadable — ${toError(error).message}`);
+        return unresolved;
+    }
+    const remaining = [];
+    for (const path of uncovered) {
+        const inputs = path === fullSuite ? undefined : await collectStagingInputs(engineDir, path);
+        const changed = await findChangedInputs(state, anchor, inputs);
+        if (changed === undefined || changed.length > 0)
+            remaining.push({ path, changed: changed ?? [] });
+    }
+    return remaining;
+}