@hominis/fireforge 0.36.0 → 0.38.0

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

@@ -17,6 +17,14 @@ export interface MachOptions {
     env?: Record<string, string>;
     /** Whether to inherit stdio (show output directly) */
     inherit?: boolean;
+    /**
+     * Collapse the KNOWN mozsystemmonitor teardown traceback to one labeled
+     * line in the terminal ECHO (capture-only option). The captured
+     * stdout/stderr stay raw — the harness classifier depends on the raw
+     * traceback. Unrecognized tracebacks always echo verbatim. Opted into by
+     * the test dispatchers only.
+     */
+    annotateKnownTeardownNoise?: boolean;
 }
 /**
  * Result of running a mach command while capturing streamed output.

package/dist/src/core/mach.js

@@ -7,6 +7,7 @@ import { exec, execInherit, execInheritCapture, execSmokeRun, execStream, } from
 import { createSiblingLockPath, withFileLock } from './file-lock.js';
 import { ensureFirefoxIgnorefileCompatibility } from './firefox-ignorefile.js';
 import { explainMachError } from './mach-error-hints.js';
+import { createKnownTeardownNoiseFilter, createTeardownNoiseContext, } from './mach-known-noise-filter.js';
 import { getPython } from './mach-python.js';
 import { installMachResourceGuard } from './mach-resource-shim.js';
 import { detectHarnessCrashSignature } from './test-harness-crash.js';
@@ -42,7 +43,12 @@ export async function runMach(args, engineDir, options = {}) {
         ...(options.env ? { env: options.env } : {}),
     };
     if (options.inherit) {
-        return execInherit(python, [machPath, ...args], execOptions);
+        // Group-reap every long-lived inherited mach dispatch (bootstrap, run,
+        // watch): a mach dying at startup must not strand multiprocessing
+        // workers. Short-lived metadata queries below stay on plain exec() —
+        // adding groups there would touch every non-mach exec consumer's path
+        // for no reaping benefit.
+        return execInherit(python, [machPath, ...args], { ...execOptions, processGroup: true });
     }
     const result = await exec(python, [machPath, ...args], execOptions);
     return result.exitCode;
@@ -67,24 +73,47 @@ export async function runMachCapture(args, engineDir, options = {}) {
     const machPath = join(engineDir, 'mach');
     let stdout = '';
     let stderr = '';
+    // Echo-path filters only: the captured strings above accumulate RAW so the
+    // classifier still sees the full teardown traceback. When the option is
+    // off, the filters are absent and echo is a straight write (unchanged).
+    // One shutdown context per run, shared by both stream filters: the
+    // SUITE_END marker usually arrives on stdout while the teardown traceback
+    // lands on stderr, so the shutdown-seen flag must span the pair.
+    const noiseContext = options.annotateKnownTeardownNoise === true ? createTeardownNoiseContext() : undefined;
+    const stdoutFilter = noiseContext && createKnownTeardownNoiseFilter(noiseContext);
+    const stderrFilter = noiseContext && createKnownTeardownNoiseFilter(noiseContext);
     const exitCode = await execStream(python, [machPath, ...args], {
         cwd: engineDir,
         ...(options.env ? { env: options.env } : {}),
+        // Every capture dispatch (test suites, protected builds, package,
+        // storybook) runs as a process-group leader and is group-reaped on
+        // exit/abort — see ExecOptions.processGroup (0.37.0 item 9a).
+        processGroup: true,
         onStdout: (data) => {
             stdout += data;
             if (stdout.length > CAPTURE_TAIL_LIMIT) {
                 stdout = stdout.slice(-CAPTURE_TAIL_LIMIT);
             }
-            process.stdout.write(data);
+            process.stdout.write(stdoutFilter ? stdoutFilter.transform(data) : data);
         },
         onStderr: (data) => {
             stderr += data;
             if (stderr.length > CAPTURE_TAIL_LIMIT) {
                 stderr = stderr.slice(-CAPTURE_TAIL_LIMIT);
             }
-            process.stderr.write(data);
+            process.stderr.write(stderrFilter ? stderrFilter.transform(data) : data);
         },
     });
+    if (stdoutFilter) {
+        const residue = stdoutFilter.flush();
+        if (residue.length > 0)
+            process.stdout.write(residue);
+    }
+    if (stderrFilter) {
+        const residue = stderrFilter.flush();
+        if (residue.length > 0)
+            process.stderr.write(residue);
+    }
     return { stdout, stderr, exitCode };
 }
 /**
@@ -99,6 +128,7 @@ export async function runMachInheritCapture(args, engineDir, options = {}) {
     return execInheritCapture(python, [machPath, ...args], {
         cwd: engineDir,
         ...(options.env ? { env: options.env } : {}),
+        processGroup: true,
     });
 }
 /**
@@ -363,6 +393,7 @@ export async function testWithOutput(engineDir, testPaths = [], args = [], env)
     const guard = await installMachResourceGuard(engineDir);
     return runMachCapture(['test', ...testPaths, ...args], engineDir, {
         env: { ...guard.env, ...env },
+        annotateKnownTeardownNoise: true,
     });
 }
 /**
@@ -379,6 +410,7 @@ export async function xpcshellTestWithOutput(engineDir, testPaths = [], args = [
     const guard = await installMachResourceGuard(engineDir);
     return runMachCapture(['xpcshell-test', ...testPaths, ...args], engineDir, {
         env: { ...guard.env, ...env },
+        annotateKnownTeardownNoise: true,
     });
 }
 /**
@@ -390,5 +422,6 @@ export async function mochitestWithOutput(engineDir, testPaths = [], args = [],
     const guard = await installMachResourceGuard(engineDir);
     return runMachCapture(['mochitest', ...testPaths, ...args], engineDir, {
         env: { ...guard.env, ...env },
+        annotateKnownTeardownNoise: true,
     });
 }

package/dist/src/core/patch-lint-cross.js

@@ -343,6 +343,14 @@ function findMatchingStagedDependency(entry, sitePath, specifier, laterOwners) {
         laterOwners.some((owner) => owner.fullPath === dependency.creates &&
             (dependency.owner === undefined || dependency.owner === owner.filename)));
 }
+/**
+ * Later-in-apply-order predicate shared by the forward-import scan and the
+ * registration validation: strictly higher ordinal, or same ordinal with a
+ * lexicographically later filename (the apply loop's tiebreak).
+ */
+function isLaterOwner(owner, entry) {
+    return (owner.order > entry.order || (owner.order === entry.order && owner.filename > entry.filename));
+}
 /** Builds the basename → later-creators index used by the forward-import scan. */
 function buildNewFileIndex(ctx) {
     const newFileIndex = new Map();
@@ -382,8 +390,7 @@ function eachForwardImportSite(ctx, newFileIndex, visit) {
             const owners = newFileIndex.get(leaf);
             if (!owners)
                 continue;
-            const laterOwners = owners.filter((owner) => owner.order > entry.order ||
-                (owner.order === entry.order && owner.filename > entry.filename));
+            const laterOwners = owners.filter((owner) => isLaterOwner(owner, entry));
             if (laterOwners.length === 0)
                 continue;
             visit(entry, sitePath, specifier, cleaned, laterOwners);
@@ -477,9 +484,80 @@ export function lintPatchQueueForwardImports(ctx) {
                 severity: 'warning',
             });
         }
+        // Registration-kind declarations (0.37.0 item 5): a jar.mn packaging
+        // line, customElements registration, or actor registration referencing
+        // a later-created file. There is no import specifier to match — the
+        // declaration is "used" when the declared line (whitespace-trimmed)
+        // appears among the lines this patch adds to the declaring file AND
+        // its `creates` resolves to a file a later-ordered patch actually
+        // creates (with `owner`, when set, naming that patch) — mirroring
+        // findMatchingStagedDependency for the import kind.
+        for (const registration of entry.metadata?.stagedDependencies?.registrations ?? []) {
+            const failure = findStagedRegistrationFailure(entry, registration, newFileIndex);
+            if (failure === undefined)
+                continue;
+            issues.push({
+                file: registration.file,
+                check: 'staged-dependency-unused',
+                fingerprint: `staged-dependency-unused|${entry.filename}|${registration.file}|reg:${registration.line}|${registration.creates}|${registration.owner ?? ''}`,
+                message: `${entry.filename} declares a staged registration in ${registration.file} ` +
+                    `("${registration.line}") for ${registration.creates}, but ${describeRegistrationFailure(failure)} ` +
+                    'Remove the stale declaration with "fireforge patch staged-dependency --remove --kind registration" or update it to match the patch and queue.',
+                severity: 'warning',
+            });
+        }
     }
     return issues;
 }
+/**
+ * Validates one registration-kind declaration against the patch content
+ * and the queue, mirroring {@link findMatchingStagedDependency}: the
+ * declared line must be added by this patch, `creates` must exactly match
+ * a file a LATER-ordered patch creates (an earlier-only creator means the
+ * dependency is already satisfied and the declaration is stale), and
+ * `owner`, when set, must name one of those creating patches. Returns
+ * undefined when valid.
+ */
+function findStagedRegistrationFailure(entry, registration, newFileIndex) {
+    if (!isRegistrationLinePresent(entry, registration))
+        return { kind: 'line-absent' };
+    const creators = (newFileIndex.get(basename(registration.creates)) ?? []).filter((owner) => owner.fullPath === registration.creates && isLaterOwner(owner, entry));
+    if (creators.length === 0)
+        return { kind: 'creates-unresolved' };
+    if (registration.owner !== undefined &&
+        !creators.some((owner) => owner.filename === registration.owner)) {
+        return { kind: 'owner-mismatch', creators };
+    }
+    return undefined;
+}
+/** Message tail for each {@link StagedRegistrationFailure} shape. */
+function describeRegistrationFailure(failure) {
+    switch (failure.kind) {
+        case 'line-absent':
+            return 'the patch does not add that line.';
+        case 'creates-unresolved':
+            return ('no later-ordered patch creates that file — the declaration is stale, ' +
+                'or the queue order no longer stages it.');
+        case 'owner-mismatch':
+            return `that file is created by ${failure.creators.map((o) => o.filename).join(', ')}, not the declared owner.`;
+    }
+}
+/**
+ * True when the declared registration/packaging line appears (trimmed)
+ * among the lines the patch introduces in the declaring file — either as a
+ * newly-created file's content or as added lines to an existing file
+ * (where jar.mn / customElements.js / actor-registration edits land).
+ */
+function isRegistrationLinePresent(entry, registration) {
+    const declared = registration.line.trim();
+    if (declared.length === 0)
+        return false;
+    const introduced = [
+        entry.newFiles.get(registration.file),
+        entry.modifiedFileAdditions.get(registration.file),
+    ];
+    return introduced.some((content) => content !== undefined && content.split('\n').some((line) => line.trim() === declared));
+}
 /**
  * Cross-patch lint orchestrator. Runs every cross-patch rule against the
  * provided context and returns combined issues.

package/dist/src/core/patch-lint.d.ts

@@ -8,6 +8,9 @@ export { lintPatchedCss };
  * Counts the total lines in a unified diff and the number of non-binary
  * text lines, so binary hunks do not inflate patch size checks.
  *
+ * Line counting agrees with `wc -l`: a trailing newline does not add a
+ * phantom empty line to either `total` or the binary-hunk accounting.
+ *
  * @param diffContent - Raw unified diff string
  * @returns Object with `total` line count and `textLines` (total minus binary hunk lines)
  */

package/dist/src/core/patch-lint.js

@@ -35,15 +35,33 @@ const FILE_SIZE_THRESHOLDS = {
     general: { notice: 500, warning: 750, error: 900 },
     test: { notice: 1200, warning: 1400, error: 1600 },
 };
+/**
+ * Counts the lines of `content` the way `wc -l` reports them: a trailing
+ * newline terminates the last line rather than starting an empty extra
+ * one. A naive `split('\n').length` over-counts by one for any content
+ * ending in `\n` (the common case), which made the size rules fire one
+ * line early against the operator's own `wc -l` measurement.
+ */
+function countContentLines(content) {
+    const lines = content.split('\n');
+    if (lines[lines.length - 1] === '')
+        lines.pop();
+    return lines.length;
+}
 /**
  * Counts the total lines in a unified diff and the number of non-binary
  * text lines, so binary hunks do not inflate patch size checks.
  *
+ * Line counting agrees with `wc -l`: a trailing newline does not add a
+ * phantom empty line to either `total` or the binary-hunk accounting.
+ *
  * @param diffContent - Raw unified diff string
  * @returns Object with `total` line count and `textLines` (total minus binary hunk lines)
  */
 export function countNonBinaryDiffLines(diffContent) {
     const lines = diffContent.split('\n');
+    if (lines[lines.length - 1] === '')
+        lines.pop();
     const total = lines.length;
     let binaryLines = 0;
     let inBinaryHunk = false;
@@ -329,12 +347,12 @@ export async function lintPatchedJs(repoDir, affectedFiles, newFiles, config, pa
         }
         // 2. File size check (new files only)
         if (isNew) {
-            const lineCount = content.split('\n').length;
+            const lineCount = countContentLines(content);
             const isTest = isTestFile(file);
             const thresholds = isTest ? FILE_SIZE_THRESHOLDS.test : FILE_SIZE_THRESHOLDS.general;
             const label = isTest ? 'Test file' : 'New file';
             const verb = isTest ? 'splitting' : 'decomposing';
-            if (lineCount >= thresholds.error) {
+            if (lineCount > thresholds.error) {
                 issues.push({
                     file,
                     check: 'file-too-large',
@@ -342,7 +360,7 @@ export async function lintPatchedJs(repoDir, affectedFiles, newFiles, config, pa
                     severity: 'error',
                 });
             }
-            else if (lineCount >= thresholds.warning) {
+            else if (lineCount > thresholds.warning) {
                 issues.push({
                     file,
                     check: 'file-too-large',
@@ -350,7 +368,7 @@ export async function lintPatchedJs(repoDir, affectedFiles, newFiles, config, pa
                     severity: 'warning',
                 });
             }
-            else if (lineCount >= thresholds.notice) {
+            else if (lineCount > thresholds.notice) {
                 issues.push({
                     file,
                     check: 'file-too-large',
@@ -507,7 +525,7 @@ export function lintPatchSize(filesAffected, lineCount, patchTier) {
             severity: 'warning',
         });
     }
-    if (lineCount >= lineThresholds.error) {
+    if (lineCount > lineThresholds.error) {
         issues.push({
             file: AGGREGATE_PATCH_FILE,
             check: 'large-patch-lines',
@@ -515,7 +533,7 @@ export function lintPatchSize(filesAffected, lineCount, patchTier) {
             severity: 'error',
         });
     }
-    else if (lineCount >= lineThresholds.warning) {
+    else if (lineCount > lineThresholds.warning) {
         issues.push({
             file: AGGREGATE_PATCH_FILE,
             check: 'large-patch-lines',
@@ -523,7 +541,7 @@ export function lintPatchSize(filesAffected, lineCount, patchTier) {
             severity: 'warning',
         });
     }
-    else if (lineCount >= lineThresholds.notice) {
+    else if (lineCount > lineThresholds.notice) {
         issues.push({
             file: AGGREGATE_PATCH_FILE,
             check: 'large-patch-lines',

package/dist/src/core/patch-manifest-io.d.ts

@@ -102,8 +102,9 @@ export interface PatchRenameEntry {
     newOrder: number;
 }
 /**
- * Rewrites `stagedDependencies.forwardImports[].owner` references on one
- * patch through a rename lookup. Owners embed exact patch filenames, so any
+ * Rewrites `stagedDependencies.forwardImports[].owner` and
+ * `stagedDependencies.registrations[].owner` references on one patch
+ * through a rename lookup. Owners embed exact patch filenames, so any
  * renumber (compact, reorder, placement export, rename) that does not remap
  * them leaves dangling references that surface as false forward-import
  * errors on the next lint.

package/dist/src/core/patch-manifest-io.js

@@ -192,8 +192,9 @@ export async function removePatchFromManifest(patchesDir, filename) {
     return true;
 }
 /**
- * Rewrites `stagedDependencies.forwardImports[].owner` references on one
- * patch through a rename lookup. Owners embed exact patch filenames, so any
+ * Rewrites `stagedDependencies.forwardImports[].owner` and
+ * `stagedDependencies.registrations[].owner` references on one patch
+ * through a rename lookup. Owners embed exact patch filenames, so any
  * renumber (compact, reorder, placement export, rename) that does not remap
  * them leaves dangling references that surface as false forward-import
  * errors on the next lint.
@@ -207,25 +208,35 @@ export async function removePatchFromManifest(patchesDir, filename) {
  * @returns The same row, or a copy with remapped owners
  */
 export function rewriteStagedDependencyOwners(patch, renameLookup) {
-    const forwardImports = patch.stagedDependencies?.forwardImports;
-    if (!forwardImports || forwardImports.length === 0)
+    const staged = patch.stagedDependencies;
+    if (!staged)
         return patch;
-    const rewritten = forwardImports.map((fi) => {
-        if (!fi.owner)
-            return fi;
-        const newOwner = renameLookup(fi.owner);
-        if (newOwner === undefined || newOwner === fi.owner)
-            return fi;
-        return { ...fi, owner: newOwner };
-    });
-    const changed = rewritten.some((fi, index) => fi !== forwardImports[index]);
-    if (!changed)
+    const rewriteOwners = (entries) => {
+        if (!entries || entries.length === 0)
+            return { entries, changed: false };
+        const rewritten = entries.map((entry) => {
+            if (!entry.owner)
+                return entry;
+            const newOwner = renameLookup(entry.owner);
+            if (newOwner === undefined || newOwner === entry.owner)
+                return entry;
+            return { ...entry, owner: newOwner };
+        });
+        return {
+            entries: rewritten,
+            changed: rewritten.some((entry, index) => entry !== entries[index]),
+        };
+    };
+    const forwardImports = rewriteOwners(staged.forwardImports);
+    const registrations = rewriteOwners(staged.registrations);
+    if (!forwardImports.changed && !registrations.changed)
         return patch;
     return {
         ...patch,
         stagedDependencies: {
-            ...patch.stagedDependencies,
-            forwardImports: rewritten,
+            ...staged,
+            ...(forwardImports.entries !== undefined ? { forwardImports: forwardImports.entries } : {}),
+            ...(registrations.entries !== undefined ? { registrations: registrations.entries } : {}),
         },
     };
 }

package/dist/src/core/patch-manifest-validate.js

@@ -24,13 +24,37 @@ function parseForwardImports(data, label) {
         return dependency;
     });
 }
+function parseRegistrations(data, label) {
+    if (!isArray(data)) {
+        throw new Error(`${label} must be an array`);
+    }
+    return data.map((entry, index) => {
+        const rec = parseObject(entry, `${label}[${index}]`);
+        const dependency = {
+            file: rec.string('file'),
+            line: rec.string('line'),
+            creates: rec.string('creates'),
+        };
+        const owner = rec.optionalString('owner');
+        if (owner !== undefined)
+            dependency.owner = owner;
+        const reason = rec.optionalString('reason');
+        if (reason !== undefined)
+            dependency.reason = reason;
+        return dependency;
+    });
+}
 function parseStagedDependencies(data, label) {
     const rec = parseObject(data, label);
     const rawForwardImports = rec.raw('forwardImports');
+    const rawRegistrations = rec.raw('registrations');
     const staged = {};
     if (rawForwardImports !== undefined) {
         staged.forwardImports = parseForwardImports(rawForwardImports, `${label}.forwardImports`);
     }
+    if (rawRegistrations !== undefined) {
+        staged.registrations = parseRegistrations(rawRegistrations, `${label}.registrations`);
+    }
     return staged;
 }
 /**

package/dist/src/core/status-classify.d.ts

@@ -11,12 +11,21 @@
  *   normal after `fireforge import`.
  * - `patch-owned-drift`: the file is claimed by exactly one patch, but
  *   the live engine content no longer matches that patch's expected
- *   post-apply content.
+ *   post-apply content. This includes furnace-prefixed paths: a path
+ *   can be both Furnace-managed and patch-claimed (export a deployed
+ *   component, then edit the workspace source and `furnace deploy`
+ *   again — the deployed copy now has content the patch body lacks).
+ *   Before 0.38.0 the furnace prefix check ran first and silently
+ *   bucketed such files as `furnace`, so `status` reported the stale
+ *   patch as owned.
  * - `unmanaged`: edits not explained by any patch or tool — local
  *   drift to export or discard.
  * - `branding`: files under tool-managed branding paths, written by
  *   FireForge's branding pipeline.
- * - `furnace`: files under Furnace-managed component prefixes.
+ * - `furnace`: files under Furnace-managed component prefixes. When
+ *   exactly one patch also claims the path, this bucket asserts the
+ *   live content matches that patch's expected post-apply content —
+ *   a mismatch is reported as `patch-owned-drift` instead (see above).
  * - `conflict`: the file is claimed by two or more patches in
  *   `patches.json`. The human `--ownership` mode already surfaces
  *   this bucket as `CONFLICT`; the classification is carried through

package/dist/src/core/status-classify.js

@@ -55,6 +55,40 @@ function isGeneratedBrandingPath(file, binaryName) {
         normalized === `${brandingRoot}/locales/en-US/brand.properties` ||
         normalized === `${brandingRoot}/locales/en-US/brand.ftl`);
 }
+/**
+ * Compares a single-owner file's live engine content against its owning
+ * patch's expected post-apply content. `matchClassification` is what a
+ * clean match reports — `patch-backed` for ordinary patch-claimed paths,
+ * `furnace` for furnace-prefixed paths so healthy deployed components
+ * keep landing in the pinned furnace bucket. Any mismatch (including a
+ * deletion the patch does not expect, or a failed comparison) reports
+ * `patch-owned-drift`.
+ */
+async function classifySingleOwnerFile(entry, engineDir, patchesDir, matchClassification) {
+    if (getPrimaryStatusCode(entry.status) === 'D') {
+        // Deleted file: content matches only if the patch expects deletion
+        const expected = await computePatchedContent(patchesDir, engineDir, entry.file);
+        return {
+            ...entry,
+            classification: expected === null ? matchClassification : 'patch-owned-drift',
+        };
+    }
+    // File exists on disk — compare actual vs expected
+    try {
+        const [expected, actual] = await Promise.all([
+            computePatchedContent(patchesDir, engineDir, entry.file),
+            readText(join(engineDir, entry.file)),
+        ]);
+        return {
+            ...entry,
+            classification: actual === expected ? matchClassification : 'patch-owned-drift',
+        };
+    }
+    catch (error) {
+        verbose(`Treating ${entry.file} as patch-owned drift because patch-backed classification failed: ${toError(error).message}`);
+        return { ...entry, classification: 'patch-owned-drift' };
+    }
+}
 /**
  * Classifies files into patch-backed, unmanaged, branding, furnace, or
  * conflict buckets.
@@ -104,7 +138,20 @@ export async function classifyFiles(files, engineDir, patchesDir, binaryName, fu
                 }
             }
             if (isFurnace) {
-                results.push({ ...entry, classification: 'furnace' });
+                // A furnace path claimed by exactly one patch gets the same
+                // expected-vs-actual comparison as any other single-owner path:
+                // after a `furnace deploy` of an edited component the deployed
+                // copy has content the owning patch's body lacks, and the old
+                // unconditional short-circuit silently bucketed that drift as
+                // `furnace`. Multi-owner and unowned furnace paths keep the
+                // short-circuit — the ownership table independently flags
+                // filesAffected conflicts.
+                if (owners && owners.length === 1) {
+                    results.push(await classifySingleOwnerFile(entry, engineDir, patchesDir, 'furnace'));
+                }
+                else {
+                    results.push({ ...entry, classification: 'furnace' });
+                }
                 continue;
             }
         }
@@ -127,30 +174,7 @@ export async function classifyFiles(files, engineDir, patchesDir, binaryName, fu
             continue;
         }
         // File is claimed by exactly one patch — compare content.
-        if (primaryCode === 'D') {
-            // Deleted file: patch-backed only if patch expects deletion
-            const expected = await computePatchedContent(patchesDir, engineDir, entry.file);
-            results.push({
-                ...entry,
-                classification: expected === null ? 'patch-backed' : 'patch-owned-drift',
-            });
-            continue;
-        }
-        // File exists on disk — compare actual vs expected
-        try {
-            const [expected, actual] = await Promise.all([
-                computePatchedContent(patchesDir, engineDir, entry.file),
-                readText(join(engineDir, entry.file)),
-            ]);
-            results.push({
-                ...entry,
-                classification: actual === expected ? 'patch-backed' : 'patch-owned-drift',
-            });
-        }
-        catch (error) {
-            verbose(`Treating ${entry.file} as patch-owned drift because patch-backed classification failed: ${toError(error).message}`);
-            results.push({ ...entry, classification: 'patch-owned-drift' });
-        }
+        results.push(await classifySingleOwnerFile(entry, engineDir, patchesDir, 'patch-backed'));
     }
     return results;
 }

package/dist/src/core/test-harness-crash.d.ts

@@ -34,6 +34,14 @@ export interface HarnessRunVerdict {
     signature?: HarnessCrashSignature;
     /** First concrete test-failure evidence line, when available. */
     realFailureLine?: string;
+    /**
+     * First N `TEST-UNEXPECTED-*` lines verbatim, each with its trailing
+     * assertion/diff context lines (`Got …` / `Expected …` / Assert diff /
+     * stack head). Lets the failure summary echo the actual assertion so a
+     * one-off failure that does not reproduce is still diagnosable after the
+     * fact. Only set on `test-failures` verdicts when such lines exist.
+     */
+    realFailureBlocks?: string[];
     /** Harness noise seen in the same output as a real test failure. */
     secondaryHarnessSignature?: HarnessCrashSignature;
     /**
@@ -104,6 +112,14 @@ export declare function analyzeTestCompleteness(output: string, requestedPaths:
     neverStarted: string[];
     neverEnded: string[];
 };
+/**
+ * Collects the first `limit` TEST-UNEXPECTED-* lines with their trailing
+ * assertion/diff context, one string per block. The shutdown-reentry
+ * artifact is excluded (it is harness noise, not a test result). When more
+ * than `limit` blocks exist, a final `…(+N more …)` note is appended so the
+ * operator knows the echo was truncated. Pure; exported for unit tests.
+ */
+export declare function collectUnexpectedFailureBlocks(output: string, limit?: number): string[];
 /**
  * Detects the known harness-crash shapes in captured mach output.
  * Returns undefined for anything that looks like a genuine test result.