chore: merge main into codex/audit-macho-facts

* test(ghidra): keep the bridge context contract out of an empty suite

Source tests collect src/ghidra/GhidraFunctionValues.test.ts directly.
The empty describe failed that file with "No test found in suite" even
though every shard passed. Assert the bridge bindings at file level.

* test(ghidra): retire superseded source-text context assertions

Co-authored-by: gensokyo-dev <[email protected]>

---------

Co-authored-by: Cursor Agent <[email protected]>
Co-authored-by: N0zoM1z0 <[email protected]>
Co-authored-by: gensokyo-dev <[email protected]>

.github/workflows/ghidra-bridge-sources.yml

@@ -25,7 +25,7 @@ jobs:
           node-version-file: .nvmrc
       - name: Validate the SDK pin against the provider's verified release
         run: node scripts/verify-ghidra-bridge-sources.mjs --check-sdk-pin >> "$GITHUB_ENV"
-      # The bridge probe imports only source-owned ARM/Thumb bytes and never
+      # The bridge probe imports only source-owned ARM, Thumb and MIPS bytes and never
       # executes target code. All SDK/project state stays in runner storage.
       - name: Acquire checksum-verified Ghidra SDK in isolated runner storage
         shell: bash
@@ -46,7 +46,7 @@ jobs:
           java_home_variable="JAVA_HOME_${GHIDRA_JAVA_MAJOR}_X64"
           test -n "${!java_home_variable}"
           JAVA_HOME="${!java_home_variable}" npm run verify:ghidra:bridge-sources -- --verified-sdk
-      - name: Inspect real ARM and Thumb instruction context through the bridge
+      - name: Inspect real ARM, Thumb and MIPS instruction context through the bridge
         shell: bash
         run: |
           java_home_variable="JAVA_HOME_${GHIDRA_JAVA_MAJOR}_X64"
@@ -58,10 +58,21 @@ jobs:
             -import "${probe_root}/arm-thumb.bin" -loader BinaryLoader -processor ARM:LE:32:v7 \
             -noanalysis -readOnly -deleteProject \
             -scriptPath "${GITHUB_WORKSPACE}/tests/conformance/ghidra;${GITHUB_WORKSPACE}/bridge/ghidra" \
-            -postScript ReaArmContextProbe.java "${GITHUB_WORKSPACE}/bridge/ghidra" \
+            -postScript ReaInstructionContextProbe.java "${GITHUB_WORKSPACE}/bridge/ghidra" \
             > "${probe_root}/output.log" 2>&1 || { cat "${probe_root}/output.log"; exit 1; }
           cat "${probe_root}/output.log"
           grep -F 'REA_ARM_CONTEXT_OK arm=0 thumb=1 unavailable=null (injected provider value)' "${probe_root}/output.log"
+          mkdir -p "${probe_root}/mips-project"
+          # MIPS32 addiu v0,a0,3; MIPS16 li v0,90. These bytes are never executed.
+          printf '\003\000\202\044\132\152\000\000' > "${probe_root}/mips.bin"
+          timeout 180s "${GHIDRA_INSTALL_DIR}/support/analyzeHeadless" "${probe_root}/mips-project" MipsContext \
+            -import "${probe_root}/mips.bin" -loader BinaryLoader -processor MIPS:LE:32:default \
+            -noanalysis -readOnly -deleteProject \
+            -scriptPath "${GITHUB_WORKSPACE}/tests/conformance/ghidra;${GITHUB_WORKSPACE}/bridge/ghidra" \
+            -postScript ReaInstructionContextProbe.java "${GITHUB_WORKSPACE}/bridge/ghidra" mips \
+            > "${probe_root}/mips-output.log" 2>&1 || { cat "${probe_root}/mips-output.log"; exit 1; }
+          cat "${probe_root}/mips-output.log"
+          grep -F 'REA_MIPS_CONTEXT_OK standard=0 mips16=1' "${probe_root}/mips-output.log"
       # Each probe imports source-owned bytes at 0x1000, away from the Cortex-M
       # vector symbols that ARMCortex.pspec defines at 0, and decodes them from
       # the language's default context, so M-profile Thumb state must hold at

docs/guides/native/native-investigation.md

@@ -1031,6 +1031,11 @@ complete observation.
     arm64e formats;
   - legacy `LC_DYLD_INFO` rebase and bind opcodes.
 
+  Text relocation records retain their import identity without claiming a
+  pointer value. Bind types are explicit: a non-lazy binding with no declared
+  type is invalid. Reads that overlap only part of an encoded chained-fixup word remain
+  unresolved rather than treating those stored bytes as an ordinary pointer.
+
   [dyld symbol names are byte strings](https://github.com/apple-oss-distributions/dyld/blob/dyld-1330/mach_o/BindOpcodes.cpp#L203-L208),
   compared with [`strcmp`](https://github.com/apple-oss-distributions/dyld/blob/dyld-1330/mach_o/BindOpcodes.cpp#L42-L56).
   Dependent library install names likewise originate as

docs/specs/README.md

@@ -26,6 +26,7 @@ for new work, roadmap granularity and producer-owned contracts.
 - [Native call source coordinates](native/call-source-locations/spec.md) ([plan](native/call-source-locations/plan.md), [tasks](native/call-source-locations/tasks.md), [verification](native/call-source-locations/verification.md))
 - [Go static string-header literal recovery](native/go-string-literals/spec.md) ([plan](native/go-string-literals/plan.md), [tasks](native/go-string-literals/tasks.md))
 - [Windows Shell Link shortcut inspection](native/windows-shortcut/spec.md) ([plan](native/windows-shortcut/plan.md), [tasks](native/windows-shortcut/tasks.md))
+- [NTFS $MFT and USN Journal inspection](native/ntfs-mft/spec.md) ([plan](native/ntfs-mft/plan.md), [tasks](native/ntfs-mft/tasks.md))
 - [Solidity terminal metadata inspection](solidity/cbor-metadata/spec.md) ([plan](solidity/cbor-metadata/plan.md), [tasks](solidity/cbor-metadata/tasks.md), [verification](solidity/cbor-metadata/verification.md))
 - [Inspect a V8 code cache container](v8/code-cache-inspection/spec.md) ([plan](v8/code-cache-inspection/plan.md), [tasks](v8/code-cache-inspection/tasks.md))
 - [Deno compile executable inventory and extraction](artifacts/deno-standalone/spec.md) ([plan](artifacts/deno-standalone/plan.md), [tasks](artifacts/deno-standalone/tasks.md))

docs/specs/native/ntfs-mft/plan.md

@@ -0,0 +1,39 @@
+# Implementation plan
+
+## Boundary and contract
+
+Follow the existing artifact readers. `src/domain/windows/ntfsMft.ts` owns FILE
+record bytes and coverage; `src/domain/artifactFormatMetadata.ts` owns the
+`ntfs-mft` result schema. `NtfsMftArtifactReader` reads the admitted file
+through `ArtifactFileSource` and exposes its facts through `formatMetadata()`.
+A record stream is its own content, so the root occurrence carries every fact
+and no members are enumerated.
+
+Recognition lives in `hasMftFileRecordSignature` and is applied in
+`classifyArtifactBytes`, next to the other unambiguous magic probes.
+
+## Incremental work and validation
+
+1. Define the first-step contract, limits and observations; add parser fixtures.
+2. Implement the FILE record header and update-sequence fixup parse with
+   explicit limitations.
+3. Add the reader, format descriptor and byte classification.
+4. Decode attribute records, then `$FILE_NAME` attributes so a record's parent
+   reference, names and timestamps become explicit; keep hard links separate.
+5. Parse `$UsnJrnl:$J` records and correlate them to records by full file
+   reference, including sequence numbers, reporting unresolved references.
+6. Document the workflow in a native Windows artifact guide.
+
+## Effects and compatibility
+
+The workflow reads one caller-selected local file. It adds no target execution,
+injection, mutation, protection recovery, network access, volume mount or live
+filesystem access, so no maintainer scope decision is required.
+`inspect_artifact` routing for every existing format is unchanged, and the new
+format id appears only for bytes whose first record carries the `FILE`
+signature.
+
+## References
+
+- https://learn.microsoft.com/en-us/windows/win32/fileio/master-file-table
+- https://github.com/libyal/libfsntfs/blob/main/documentation/New%20Technologies%20File%20System%20(NTFS).asciidoc

docs/specs/native/ntfs-mft/spec.md

@@ -0,0 +1,51 @@
+# NTFS $MFT and USN Journal inspection
+
+This specification records an implementation increment and its original problem
+statement. For current behavior and limitations, see the artifact inventory
+guide.
+
+## Problem and outcome
+
+REA has no reader for acquired NTFS metadata artifacts. An analyst holding a
+captured `$MFT` stream cannot ask which FILE records it contains, whether their
+update-sequence fixups survived acquisition, or which records are directories,
+extensions of another record, or no longer in use. Add offline, read-only
+inventory of a selected `$MFT` file, delivered in steps so each one merges on
+its own.
+
+## Requirements
+
+- Recognize a `$MFT` stream by a plausible first `FILE` record header under
+  any file name. CLI and MCP target admission route it to the artifact reader.
+- Validate each FILE record header: the `FILE` signature, sequence number, flags,
+  used and total byte counts, base record reference, and the update-sequence
+  array's offset, count and array bounds.
+- Verify the update-sequence fixups: every sector trailer the array covers must
+  hold the array's sequence number. A mismatch keeps the record's header facts
+  and is reported per record and in the metadata count.
+- Report a missing, misplaced or short update-sequence array as unverified
+  rather than as a clean record, and a trailing partial record as a byte count.
+- Report the first invalid record signature and the number of invalid slots.
+  Continue at the next slot when the stream declared a supported record size.
+  With a fallback record size, stop at the first invalid signature.
+- Bound the whole file at a fixed 512 MiB ceiling and report the ceiling as a
+  `limit` failure with its boundary.
+- Return the first 32 decoded record headers with their source offsets and the
+  number of omitted headers. Aggregate counts cover the full parsed stream.
+- Parse only the records' headers and fixups. Attributes, filenames, data
+  streams and the `$UsnJrnl:$J` journal are not decoded in this step, so no path,
+  file size, file reference correlation or change history is claimed.
+
+## Acceptance
+
+Synthesized fixtures cover a clean record, a failed fixup, a missing update
+sequence array, an array shorter than the record's sector count, extension and
+directory records, a record whose signature is wrong mid-stream, a trailing
+partial record, an undeclared record size, a 4 KiB record, a stream shorter than
+one header, bytes without the `FILE` signature, and the file-size ceiling.
+Inventory tests cover the root occurrence's metadata and the coverage status
+when a fixup fails, and classification tests cover several file names for the
+same bytes.
+
+Not covered in this step: real `$MFT` files written by a Windows host, USN
+journal records, attribute decoding, and any correlation between the two.

docs/specs/native/ntfs-mft/tasks.md

@@ -0,0 +1,11 @@
+# Tasks
+
+- [x] Define the first-step scope, contract and limits.
+- [x] Parse FILE record headers and update-sequence fixups with synthesized
+      fixtures and explicit limitations.
+- [x] Add the reader, format descriptor and byte classification.
+- [ ] Decode attribute records, then `$FILE_NAME` attributes with parent
+      references, names, hard links and timestamps.
+- [ ] Parse `$UsnJrnl:$J` records and correlate them to records by full file
+      reference.
+- [ ] Verify against real `$MFT` and journal captures from a Windows host.

scripts/ci/scopes.mjs

@@ -636,7 +636,7 @@ const PATH_SCOPES = {
     "src/ghidra/GhidraJavaProperties.ts",
     "src/ghidra/GhidraReleasePolicy.ts",
     "scripts/verify-ghidra-bridge-sources.mjs",
-    "tests/conformance/ghidra/ReaArmContextProbe.java",
+    "tests/conformance/ghidra/ReaInstructionContextProbe.java",
     "tests/conformance/ghidra/ReaComputedCallCoverageProbe.java",
     "tests/conformance/ghidra/ReaDecodeProbe.java",
     ".github/workflows/ghidra-bridge-sources.yml",

scripts/verify-qlog-captures.mjs

@@ -50,7 +50,7 @@ transport.stderr?.on("data", (bytes) => {
 const ajv = new Ajv2020({ strict: false, validateFormats: false });
 const measurements = [];
 const contract = toolContract("inspect_web_network_capture");
-await withVerifierCleanup(async () => {
+const report = await withVerifierCleanup(async () => {
   try {
     await client.connect(transport);
   } catch (cause) {
@@ -196,7 +196,7 @@ await withVerifierCleanup(async () => {
     });
   }
   await client.ping();
-  const report = {
+  return {
     status: "passed",
     profile: "aioquic-1.5.0-json-0.3",
     measurements,
@@ -206,17 +206,6 @@ await withVerifierCleanup(async () => {
       "No PCAP or keylog is read by this verifier; repeated STREAM coverage is not proof of retransmission or network loss.",
     ],
   };
-  await writeFile(reportPath, JSON.stringify(report, null, 2) + "\n", {
-    flag: "wx",
-    mode: 0o600,
-  });
-  console.log(
-    JSON.stringify({
-      status: report.status,
-      cases: measurements.length,
-      report: reportPath,
-    }),
-  );
 }, [
   async () => {
     await closeVerifierResources([
@@ -225,3 +214,15 @@ await withVerifierCleanup(async () => {
     ]);
   },
 ]);
+
+await writeFile(reportPath, JSON.stringify(report, null, 2) + "\n", {
+  flag: "wx",
+  mode: 0o600,
+});
+console.log(
+  JSON.stringify({
+    status: report.status,
+    cases: measurements.length,
+    report: reportPath,
+  }),
+);

src/application/BinaryTargetResolver.ts

@@ -97,6 +97,7 @@ import {
   isDfuSeFile,
 } from "../domain/firmware/dfuse.js";
 import { hasFitImagesNode } from "../domain/firmware/fitImage.js";
+import { hasMftFileRecordHeader } from "../domain/windows/ntfsMft.js";
 import {
   locateEspFlashLayout,
   type EspFlashSelection,
@@ -816,6 +817,7 @@ const detectArtifactFormat = async (
     });
   if (esp === "esp-image") return "esp-image";
   if (hasFitImagesNode(magic)) return "fit";
+  if (hasMftFileRecordHeader(magic)) return "ntfs-mft";
   // Binary plists, including keyed archives, often use other extensions.
   if (hasBinaryPlistSignature(magic)) return "plist";
   const named = namedArtifactFormat(lower);
@@ -899,6 +901,7 @@ const isArchiveFormat = (
     "dfuse",
     "esp-flash-image",
     "fit",
+    "ntfs-mft",
   ].includes(format);
 
 /** Whether the leading bytes begin any executable header family, valid or not. */

src/application/binary/TargetFormatVocabularies.test.ts

@@ -135,6 +135,7 @@ const TARGETS: TargetFixtures = {
     espFlash: { selected: true, flashOffset: null, partitionTableOffset: null },
   },
   fit: { ...archive, format: "fit" },
+  "ntfs-mft": { ...archive, format: "ntfs-mft" },
   plist: { ...artifact, format: "plist" },
   javascript: { ...artifact, format: "javascript" },
   "source-map": { ...artifact, format: "source-map" },

src/artifacts/ArtifactReader.ts

@@ -215,6 +215,7 @@ export interface ArtifactReader {
     | "dfuse"
     | "esp-flash-image"
     | "fit"
+    | "ntfs-mft"
     | "file";
   entries(
     signal?: AbortSignal,

src/artifacts/DecodedRegionArtifactReader.ts

@@ -18,7 +18,10 @@ import {
   type ArtifactTraversalOptions,
 } from "./ArtifactReader.js";
 import { ArtifactResourceScope } from "./ArtifactResourceScope.js";
-import { assertArtifactReadActive } from "./ArtifactFileOperation.js";
+import {
+  artifactReadCancelledBy,
+  assertArtifactReadActive,
+} from "./ArtifactFileOperation.js";
 import { ArtifactFileSource } from "./ArtifactFileSource.js";
 import { readFileHandleChunks } from "../filesystem/readFileHandleChunks.js";
 import type { StableRegularFileDescriptor } from "../filesystem/RegularFile.js";
@@ -64,12 +67,14 @@ export const regionFileName = (start: number, end: number): string =>
  */
 export class DecodedRegionArtifactReader<Image> implements ArtifactReader {
   readonly #scope = new ArtifactResourceScope();
-  readonly #entries = new Map<string, ArtifactEntry>();
-  readonly #regions = new Map<string, Uint8Array>();
+  #entries = new Map<string, ArtifactEntry>();
+  #regions = new Map<string, Uint8Array>();
   readonly #streams = new Set<Readable>();
   readonly #source: ArtifactFileSource;
   readonly #decoding: RegionDecoding<Image>;
-  #prepared: Promise<void> | undefined;
+  #prepared:
+    | { signal: AbortSignal | undefined; promise: Promise<void> }
+    | undefined;
   /** Whole-file facts only; the region map is the sole owner of region bytes. */
   #described: Omit<DecodedRegions, "regions"> | undefined;
   #closing = false;
@@ -110,8 +115,27 @@ export class DecodedRegionArtifactReader<Image> implements ArtifactReader {
   ): AsyncIterable<ArtifactEntry> {
     await this.#scope.run(async () => {
       this.#assertOpen(signal);
-      this.#prepared ??= this.#prepare(signal);
-      await this.#prepared;
+      for (;;) {
+        const pending = (this.#prepared ??= {
+          signal,
+          promise: this.#prepare(signal),
+        });
+        try {
+          await pending.promise;
+          break;
+        } catch (cause: unknown) {
+          if (this.#prepared === pending) this.#prepared = undefined;
+          if (
+            pending.signal !== signal &&
+            signal?.aborted !== true &&
+            artifactReadCancelledBy(cause, pending.signal)
+          ) {
+            this.#assertOpen(signal);
+            continue;
+          }
+          throw cause;
+        }
+      }
       await this.#source.read(signal);
     });
     const coverage = this.#described?.coverage;
@@ -230,6 +254,8 @@ export class DecodedRegionArtifactReader<Image> implements ArtifactReader {
 
   async #prepare(signal?: AbortSignal): Promise<void> {
     const described = this.#decoding.describe(await this.#decode(signal));
+    const entries = new Map<string, ArtifactEntry>();
+    const regions = new Map<string, Uint8Array>();
     let index = 0;
     for (const region of described.regions) {
       if (index % 256 === 0) await setImmediate();
@@ -248,13 +274,16 @@ export class DecodedRegionArtifactReader<Image> implements ArtifactReader {
         adapterKey: `${this.#decoding.keyPrefix}:${String(index)}`,
         formatMetadata: region.formatMetadata,
       } satisfies ArtifactEntry;
-      this.#entries.set(entry.adapterKey, entry);
-      this.#regions.set(entry.adapterKey, region.bytes);
+      entries.set(entry.adapterKey, entry);
+      regions.set(entry.adapterKey, region.bytes);
       index += 1;
     }
     const { regions: _regions, ...facts } = described;
-    this.#described = facts;
     await this.#source.read(signal);
+    this.#assertOpen(signal);
+    this.#entries = entries;
+    this.#regions = regions;
+    this.#described = facts;
   }
 
   async #decode(signal?: AbortSignal): Promise<Image> {

src/artifacts/FitArtifactReader.test.ts

@@ -1,3 +1,4 @@
+import { artifactPreparationRecoveryCases } from "../../tests/fixtures/artifactReaderLifecycle.js";
 import { getEventListeners, once } from "node:events";
 import { readFile, truncate, writeFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -404,6 +405,38 @@ it("keeps the cancellation reason before admission", async () => {
   }
 });
 
+it("does not publish FIT entries when final source verification fails", async () => {
+  const path = await writeFit("partial-publication.itb", FIT_EMBEDDED);
+  const control = new FitArtifactReader(path);
+  const reader = new FitArtifactReader(path);
+  const expected = await firstEntry(control);
+  const nativeRead = ArtifactFileSource.prototype.read;
+  const physical = Object.assign(
+    new Error("final source verification failed"),
+    { code: "EIO" },
+  );
+  let calls = 0;
+  const read = vi
+    .spyOn(ArtifactFileSource.prototype, "read")
+    .mockImplementation(function (this: ArtifactFileSource, ...args) {
+      calls += 1;
+      if (calls === 4) return Promise.reject(physical);
+      return nativeRead.apply(this, args);
+    });
+  try {
+    await expect(firstEntry(reader)).rejects.toBe(physical);
+    await expect(reader.open(expected)).rejects.toMatchObject({
+      reason: "integrity",
+    });
+    read.mockRestore();
+    expect((await firstEntry(reader)).path).toBe(expected.path);
+  } finally {
+    read.mockRestore();
+    await reader.close();
+    await control.close();
+  }
+});
+
 it("keeps the cancellation reason during hash verification", async () => {
   const reader = new FitArtifactReader(
     await writeFit("hashing.itb", LARGE_FIT),
@@ -430,6 +463,8 @@ it("keeps the cancellation reason during hash verification", async () => {
       reader.entries(controller.signal)[Symbol.asyncIterator]().next(),
     ).rejects.toMatchObject({ reason: "cancelled", cause: reason });
     expect(observer).toHaveBeenCalledWith("sha256");
+    observer.mockRestore();
+    expect((await firstEntry(reader)).kind).toBe("file");
   } finally {
     observer.mockRestore();
     await reader.close();
@@ -569,3 +604,8 @@ it("preserves a final validation failure when cancellation overlaps it", async (
     await reader.close();
   }
 });
+
+artifactPreparationRecoveryCases({
+  image: () => FIT_EMBEDDED,
+  createReader: (path, admitted) => new FitArtifactReader(path, admitted),
+});

src/artifacts/FitArtifactReader.ts

@@ -13,7 +13,10 @@ import {
   type ArtifactTraversalOptions,
 } from "./ArtifactReader.js";
 import { ArtifactResourceScope } from "./ArtifactResourceScope.js";
-import { assertArtifactReadActive } from "./ArtifactFileOperation.js";
+import {
+  artifactReadCancelledBy,
+  assertArtifactReadActive,
+} from "./ArtifactFileOperation.js";
 import { ArtifactFileSource } from "./ArtifactFileSource.js";
 import {
   createFitDigest,
@@ -30,11 +33,13 @@ const FDT_HEADER_BYTES = 40;
 export class FitArtifactReader implements ArtifactReader {
   readonly format = "fit" as const;
   readonly #scope = new ArtifactResourceScope();
-  readonly #entries = new Map<string, ArtifactEntry>();
+  #entries = new Map<string, ArtifactEntry>();
   readonly #streams = new Set<Readable>();
   readonly #path: string;
   readonly #source: ArtifactFileSource;
-  #prepared: Promise<void> | undefined;
+  #prepared:
+    | { signal: AbortSignal | undefined; promise: Promise<void> }
+    | undefined;
   #metadata: FitMetadata | undefined;
   #coverage: ArtifactReaderTraversal | undefined;
   #closing = false;
@@ -66,8 +71,27 @@ export class FitArtifactReader implements ArtifactReader {
   ): AsyncIterable<ArtifactEntry> {
     await this.#scope.run(async () => {
       this.#assertOpen(signal);
-      this.#prepared ??= this.#prepare(signal);
-      await this.#prepared;
+      for (;;) {
+        const pending = (this.#prepared ??= {
+          signal,
+          promise: this.#prepare(signal),
+        });
+        try {
+          await pending.promise;
+          break;
+        } catch (cause: unknown) {
+          if (this.#prepared === pending) this.#prepared = undefined;
+          if (
+            pending.signal !== signal &&
+            signal?.aborted !== true &&
+            artifactReadCancelledBy(cause, pending.signal)
+          ) {
+            this.#assertOpen(signal);
+            continue;
+          }
+          throw cause;
+        }
+      }
       await this.#source.read(signal);
     });
     if (this.#coverage !== undefined)
@@ -207,6 +231,7 @@ export class FitArtifactReader implements ArtifactReader {
       this.#path,
       initial.size,
     );
+    const entries = new Map<string, ArtifactEntry>();
     let index = 0;
     for (const image of structure.images) {
       if (index % 256 === 0) await setImmediate();
@@ -228,15 +253,17 @@ export class FitArtifactReader implements ArtifactReader {
         adapterKey: `fit:${String(image.index)}`,
         formatMetadata: image.metadata,
       } satisfies ArtifactEntry;
-      this.#entries.set(entry.adapterKey, entry);
+      entries.set(entry.adapterKey, entry);
     }
+    await this.#source.read(signal);
+    this.#assertOpen(signal);
+    this.#entries = entries;
     this.#metadata = structure.metadata;
     if (structure.limitations.length > 0)
       this.#coverage = {
         status: "complete",
         limitations: structure.limitations,
       };
-    await this.#source.read(signal);
   }
 
   /** One streamed pass per image feeds every supported digest. */

src/artifacts/HexRecordArtifactReader.test.ts

@@ -1,3 +1,6 @@
+import { artifactPreparationRecoveryCases } from "../../tests/fixtures/artifactReaderLifecycle.js";
+import { ArtifactFileSource } from "./ArtifactFileSource.js";
+import { openRegularFile } from "../filesystem/RegularFile.js";
 import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
 
@@ -159,6 +162,72 @@ it("settles an active region stream when closed", async () => {
   }
 });
 
+it("retries decoded-region preparation cancelled while reading", async () => {
+  const path = await writeImage("retry.hex", INTEL_HEX_I32_GAP);
+  const admitted = await openRegularFile(path, { symlinks: "reject" });
+  const reader = new HexRecordArtifactReader(path, "intel-hex", admitted);
+  const controller = new AbortController();
+  const reason = { stage: "decoded region read" };
+  const nativeRead = admitted.handle.read.bind(admitted.handle);
+  const read = vi.spyOn(admitted.handle, "read").mockImplementation((async (
+    ...args: unknown[]
+  ) => {
+    const result = await Reflect.apply(nativeRead, admitted.handle, args);
+    controller.abort(reason);
+    return result;
+  }) as typeof admitted.handle.read);
+  try {
+    await expect(
+      reader.entries(controller.signal)[Symbol.asyncIterator]().next(),
+    ).rejects.toMatchObject({ reason: "cancelled", cause: reason });
+    read.mockRestore();
+    expect(
+      (await reader.entries()[Symbol.asyncIterator]().next()).value,
+    ).toMatchObject({ kind: "file" });
+  } finally {
+    read.mockRestore();
+    await reader.close();
+    await admitted.handle.close();
+  }
+});
+
+it("does not publish decoded regions when final source verification fails", async () => {
+  const path = await writeImage("partial.hex", INTEL_HEX_I32_GAP);
+  const control = new HexRecordArtifactReader(path, "intel-hex");
+  const reader = new HexRecordArtifactReader(path, "intel-hex");
+  const expected = (await control.entries()[Symbol.asyncIterator]().next())
+    .value!;
+  const nativeRead = ArtifactFileSource.prototype.read;
+  const physical = Object.assign(
+    new Error("final source verification failed"),
+    { code: "EIO" },
+  );
+  let calls = 0;
+  const read = vi
+    .spyOn(ArtifactFileSource.prototype, "read")
+    .mockImplementation(function (this: ArtifactFileSource, ...args) {
+      calls += 1;
+      if (calls === 2) return Promise.reject(physical);
+      return nativeRead.apply(this, args);
+    });
+  try {
+    await expect(reader.entries()[Symbol.asyncIterator]().next()).rejects.toBe(
+      physical,
+    );
+    await expect(reader.open(expected)).rejects.toMatchObject({
+      reason: "integrity",
+    });
+    read.mockRestore();
+    expect(
+      (await reader.entries()[Symbol.asyncIterator]().next()).value,
+    ).toMatchObject({ path: expected.path });
+  } finally {
+    read.mockRestore();
+    await reader.close();
+    await control.close();
+  }
+});
+
 it("honors cancellation before admitting a file with the exact reason", async () => {
   const reader = new HexRecordArtifactReader(
     await writeImage("cancel.hex", INTEL_HEX_I32_GAP),
@@ -337,3 +406,9 @@ it("bounds copied region chunks and isolates cached bytes across opens", async (
     await reader.close();
   }
 });
+
+artifactPreparationRecoveryCases({
+  image: () => Buffer.from(INTEL_HEX_I32_GAP),
+  createReader: (path, admitted) =>
+    new HexRecordArtifactReader(path, "intel-hex", admitted),
+});

src/artifacts/NtfsMftArtifactReader.test.ts

@@ -0,0 +1,211 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import { expect, it, vi } from "vitest";
+
+import { ArtifactFileSource } from "./ArtifactFileSource.js";
+import { assertArtifactReadActive } from "./ArtifactFileOperation.js";
+import { NtfsMftArtifactReader } from "./NtfsMftArtifactReader.js";
+
+import { MFT_DEFAULT_RECORD_BYTES } from "../domain/windows/ntfsMft.js";
+import { createTestTempDirectory } from "../../tests/fixtures/temporaryDirectory.js";
+import { scanCanonicalArtifactInventory } from "../../tests/fixtures/artifactInventory.js";
+
+/** A 1 KiB FILE record whose update sequence array covers both sectors. */
+const recordBytes = (options: {
+  readonly sequenceNumber?: number;
+  readonly flags?: number;
+  readonly index?: number;
+}): Buffer => {
+  const record = Buffer.alloc(MFT_DEFAULT_RECORD_BYTES);
+  record.write("FILE", 0, "latin1");
+  const sequenceNumber = options.sequenceNumber ?? 1;
+  record.writeUInt16LE(48, 4);
+  record.writeUInt16LE(3, 6);
+  record.writeUInt16LE(sequenceNumber, 48);
+  record.writeUInt16LE(0xa5a5, 50);
+  record.writeUInt16LE(0xa5a5, 52);
+  record.writeUInt16LE(sequenceNumber, 16);
+  record.writeUInt16LE(1, 18);
+  record.writeUInt32LE(options.index ?? 0, 44);
+  record.writeUInt16LE(56, 20);
+  record.writeUInt16LE(options.flags ?? 0x0001, 22);
+  record.writeUInt32LE(64, 24);
+  record.writeUInt32LE(0xffff_ffff, 56);
+  record.writeUInt32LE(MFT_DEFAULT_RECORD_BYTES, 28);
+  record.writeUInt16LE(sequenceNumber, 510);
+  record.writeUInt16LE(sequenceNumber, 1022);
+  return record;
+};
+
+const writeMft = async (name: string, bytes: Buffer): Promise<string> => {
+  const directory = await createTestTempDirectory("rea-ntfs-mft-");
+  const path = join(directory, name);
+  await writeFile(path, bytes);
+  return path;
+};
+
+it("reports a $MFT stream's record headers as the root occurrence", async () => {
+  const inventory = await scanCanonicalArtifactInventory(
+    await writeMft(
+      "$MFT",
+      Buffer.concat([
+        recordBytes({}),
+        recordBytes({ flags: 0x0003, index: 1 }),
+      ]),
+    ),
+  );
+  expect(inventory.manifest.root_format).toBe("ntfs-mft");
+  expect(inventory.coverage.status).toBe("complete");
+  // A record stream declares no members, so the root is its whole inventory.
+  expect(inventory.occurrences.map((row) => row.logical_path)).toEqual(["."]);
+  expect(inventory.occurrences[0]).toMatchObject({
+    artifact_format: "ntfs-mft",
+    format_metadata: {
+      kind: "ntfs-mft",
+      record_bytes: MFT_DEFAULT_RECORD_BYTES,
+      record_count: 2,
+      in_use_record_count: 2,
+      directory_record_count: 1,
+      extension_record_count: 0,
+      fixup_mismatch_count: 0,
+      fixup_unverified_record_count: 0,
+      truncated_tail_bytes: 0,
+    },
+  });
+});
+
+it("names a failed fixup in the coverage limitations", async () => {
+  const record = recordBytes({ sequenceNumber: 4 });
+  // A trailer that is not the sequence number marks the sector as not cleanly written.
+  record.writeUInt16LE(0x1234, 510);
+  const inventory = await scanCanonicalArtifactInventory(
+    await writeMft("$MFT", record),
+  );
+  expect(inventory.manifest.root_format).toBe("ntfs-mft");
+  expect(inventory.coverage.status).toBe("unknown");
+  expect(inventory.limitations).toContainEqual(
+    expect.stringMatching(/sector trailer that is not the update sequence/u),
+  );
+});
+
+it("reports an unaligned used-byte count as incomplete coverage", async () => {
+  const record = recordBytes({});
+  record.writeUInt32LE(57, 24);
+  const inventory = await scanCanonicalArtifactInventory(
+    await writeMft("$MFT", record),
+  );
+  expect(inventory.coverage.status).toBe("unknown");
+  expect(inventory.occurrences[0]?.format_metadata).toMatchObject({
+    record_headers: [{ usedBytes: 57, extentValid: false }],
+  });
+});
+
+it("reports incomplete coverage when FILE extents contradict the record slots", async () => {
+  const usedTooLarge = recordBytes({});
+  usedTooLarge.writeUInt32LE(4096, 24);
+  const totalTooSmall = recordBytes({});
+  totalTooSmall.writeUInt32LE(512, 28);
+
+  const inventory = await scanCanonicalArtifactInventory(
+    await writeMft("$MFT", Buffer.concat([usedTooLarge, totalTooSmall])),
+  );
+  expect(inventory.coverage.status).toBe("unknown");
+  expect(inventory.limitations).toContainEqual(
+    "2 FILE record(s) declare inconsistent record extents, beginning at offset 0",
+  );
+  expect(inventory.occurrences[0]?.format_metadata).toMatchObject({
+    record_count: 2,
+    fixup_mismatch_count: 0,
+    fixup_unverified_record_count: 0,
+  });
+});
+
+it("retries after final source verification fails without publishing its metadata", async () => {
+  const reader = new NtfsMftArtifactReader(
+    await writeMft("$MFT", recordBytes({})),
+  );
+  const read = ArtifactFileSource.prototype.read;
+  const spy = vi
+    .spyOn(ArtifactFileSource.prototype, "read")
+    .mockImplementationOnce(function (this: ArtifactFileSource, signal) {
+      return read.call(this, signal);
+    })
+    .mockRejectedValueOnce(new Error("final source verification failed"));
+  try {
+    await expect(
+      reader.entries()[Symbol.asyncIterator]().next(),
+    ).rejects.toThrow("final source verification failed");
+    expect(reader.formatMetadata()).toBeUndefined();
+    await expect(
+      reader.entries()[Symbol.asyncIterator]().next(),
+    ).resolves.toMatchObject({
+      done: true,
+    });
+    expect(reader.formatMetadata()).toMatchObject({
+      kind: "ntfs-mft",
+      record_count: 1,
+    });
+  } finally {
+    spy.mockRestore();
+    await reader.close();
+  }
+});
+
+it("retries a shared preparation cancelled by another traversal", async () => {
+  const reader = new NtfsMftArtifactReader(
+    await writeMft("$MFT", recordBytes({})),
+  );
+  const controller = new AbortController();
+  let entered: () => void = () => {};
+  const started = new Promise<void>((resolve) => {
+    entered = resolve;
+  });
+  const read = ArtifactFileSource.prototype.read;
+  const spy = vi
+    .spyOn(ArtifactFileSource.prototype, "read")
+    .mockImplementationOnce(async function (this: ArtifactFileSource, signal) {
+      entered();
+      await new Promise<void>((resolve) => {
+        signal?.addEventListener("abort", () => resolve(), { once: true });
+      });
+      assertArtifactReadActive(signal);
+      return read.call(this, signal);
+    });
+  try {
+    const cancelled = reader
+      .entries(controller.signal)
+      [Symbol.asyncIterator]()
+      .next();
+    const cancelledResult = expect(cancelled).rejects.toMatchObject({
+      reason: "cancelled",
+    });
+    await started;
+    const other = reader.entries()[Symbol.asyncIterator]().next();
+    controller.abort("cancelled first traversal");
+    await cancelledResult;
+    await expect(other).resolves.toMatchObject({ done: true });
+    expect(reader.formatMetadata()).toMatchObject({ record_count: 1 });
+  } finally {
+    controller.abort();
+    spy.mockRestore();
+    await reader.close();
+  }
+});
+
+it("revalidates the source before reusing a completed header inventory", async () => {
+  const path = await writeMft("$MFT", recordBytes({}));
+  const reader = new NtfsMftArtifactReader(path);
+  try {
+    await reader.entries()[Symbol.asyncIterator]().next();
+    await writeFile(
+      path,
+      Buffer.concat([recordBytes({}), recordBytes({ index: 1 })]),
+    );
+    await expect(
+      reader.entries()[Symbol.asyncIterator]().next(),
+    ).rejects.toMatchObject({ reason: "integrity" });
+  } finally {
+    await reader.close();
+  }
+});

src/artifacts/NtfsMftArtifactReader.ts

@@ -0,0 +1,174 @@
+import type { Readable } from "node:stream";
+
+import {
+  ntfsMftMetadataSchema,
+  type ArtifactFormatMetadata,
+} from "../domain/artifactFormatMetadata.js";
+import type { RegionDecodeFailure } from "../domain/firmware/regionDecoder.js";
+import {
+  createMftDecoder,
+  type MftInventory,
+} from "../domain/windows/ntfsMft.js";
+import {
+  ArtifactReaderFailure,
+  type ArtifactEntry,
+  type ArtifactReader,
+  type ArtifactReaderTraversal,
+  type ArtifactTraversalOptions,
+} from "./ArtifactReader.js";
+import { ArtifactResourceScope } from "./ArtifactResourceScope.js";
+import {
+  artifactReadCancelledBy,
+  assertArtifactReadActive,
+} from "./ArtifactFileOperation.js";
+import { ArtifactFileSource } from "./ArtifactFileSource.js";
+import { readFileHandleChunks } from "../filesystem/readFileHandleChunks.js";
+import type { StableRegularFileDescriptor } from "../filesystem/RegularFile.js";
+
+/**
+ * An MFT stream is its own content: the FILE records describe the source
+ * volume, not members inside the stream, so header facts are attached to
+ * the root occurrence.
+ */
+export class NtfsMftArtifactReader implements ArtifactReader {
+  readonly format = "ntfs-mft" as const;
+  readonly #scope = new ArtifactResourceScope();
+  readonly #source: ArtifactFileSource;
+  #prepared:
+    | { signal: AbortSignal | undefined; promise: Promise<void> }
+    | undefined;
+  #metadata: ArtifactFormatMetadata | undefined;
+  #limitations: readonly string[] = [];
+  #closing = false;
+
+  constructor(path: string, admitted?: StableRegularFileDescriptor) {
+    this.#source = new ArtifactFileSource(path, "$MFT stream", admitted);
+  }
+
+  formatMetadata(): ArtifactFormatMetadata | undefined {
+    return this.#metadata === undefined
+      ? undefined
+      : structuredClone(this.#metadata);
+  }
+
+  async prepareContainer(
+    expectedSha256: string,
+    signal?: AbortSignal,
+  ): Promise<void> {
+    await this.#scope.run(async () => {
+      this.#assertOpen(signal);
+      await this.#source.bindSha256(expectedSha256, signal);
+    });
+  }
+
+  async *entries(
+    signal?: AbortSignal,
+    options?: ArtifactTraversalOptions,
+  ): AsyncIterable<ArtifactEntry> {
+    await this.#scope.run(async () => {
+      this.#assertOpen(signal);
+      for (;;) {
+        const pending = (this.#prepared ??= {
+          signal,
+          promise: this.#prepare(signal),
+        });
+        try {
+          await pending.promise;
+          break;
+        } catch (cause: unknown) {
+          if (this.#prepared === pending) this.#prepared = undefined;
+          if (
+            pending.signal !== signal &&
+            signal?.aborted !== true &&
+            artifactReadCancelledBy(cause, pending.signal)
+          ) {
+            this.#assertOpen(signal);
+            continue;
+          }
+          throw cause;
+        }
+      }
+      this.#assertOpen(signal);
+      await this.#source.read(signal);
+    });
+    // An MFT declares no members, so the root occurrence is the whole
+    // inventory; the coverage callback reports what its parse did not establish.
+    options?.onCoverage?.(coverageOf(this.#limitations));
+  }
+
+  async open(entry: ArtifactEntry, _signal?: AbortSignal): Promise<Readable> {
+    return this.#scope.run(async () => {
+      throw new ArtifactReaderFailure(
+        "unavailable",
+        `$MFT stream declares no member to open for ${entry.path}`,
+      );
+    });
+  }
+
+  async close(): Promise<void> {
+    this.#closing = true;
+    await this.#scope.close();
+    await this.#source.close();
+    this.#metadata = undefined;
+  }
+
+  provenance(): readonly [] {
+    return [];
+  }
+
+  #assertOpen(signal?: AbortSignal): void {
+    assertArtifactReadActive(signal);
+    if (this.#closing)
+      throw new ArtifactReaderFailure(
+        "unavailable",
+        "$MFT stream reader is closed",
+      );
+  }
+
+  async #prepare(signal?: AbortSignal): Promise<void> {
+    const image = await this.#decode(signal);
+    await this.#source.read(signal);
+    this.#metadata = ntfsMftMetadataSchema.parse(image.metadata);
+    this.#limitations = image.limitations;
+  }
+
+  async #decode(signal?: AbortSignal): Promise<MftInventory> {
+    const { handle, initial } = await this.#source.read(signal);
+    const decoder = createMftDecoder(initial.size);
+    if (!decoder.ok) throw this.#failure(decoder.error);
+    if (initial.size > 0)
+      for await (const chunk of readFileHandleChunks(handle, {
+        end: initial.size - 1,
+        signal,
+        cancellationFailure: (reason) =>
+          new ArtifactReaderFailure("cancelled", "$MFT stream read cancelled", {
+            cause: reason,
+          }),
+      }) as AsyncIterable<Buffer>) {
+        this.#assertOpen(signal);
+        const written = decoder.value.write(chunk);
+        if (!written.ok) throw this.#failure(written.error);
+      }
+    const image = decoder.value.finish();
+    if (!image.ok) throw this.#failure(image.error);
+    return image.value;
+  }
+
+  #failure(failure: RegionDecodeFailure): ArtifactReaderFailure {
+    return failure.kind === "format"
+      ? new ArtifactReaderFailure(
+          "format",
+          `$MFT stream is malformed: ${failure.message}`,
+        )
+      : new ArtifactReaderFailure(
+          "limit",
+          `$MFT stream exceeds a fixed limit: ${failure.message}`,
+          failure.boundary === undefined ? {} : { boundary: failure.boundary },
+        );
+  }
+}
+
+const coverageOf = (limitations: readonly string[]): ArtifactReaderTraversal =>
+  limitations.length === 0
+    ? { status: "complete", limitations: [] }
+    : { status: "unknown", limitations };

src/artifacts/UImageArtifactReader.boundaries.test.ts

@@ -1,4 +1,7 @@
-import { artifactReaderLifecycleCases } from "../../tests/fixtures/artifactReaderLifecycle.js";
+import {
+  artifactPreparationRecoveryCases,
+  artifactReaderLifecycleCases,
+} from "../../tests/fixtures/artifactReaderLifecycle.js";
 import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { buffer } from "node:stream/consumers";
@@ -91,6 +94,14 @@ it("preserves cancellation during payload CRC admission", async () => {
         }
       })(),
     ).rejects.toMatchObject({ reason: "cancelled", cause: reason });
+    reads.mockRestore();
+    const recovered = await entries(reader);
+    expect(recovered).toHaveLength(1);
+    expect(
+      (await buffer(await reader.open(recovered[0]!))).equals(
+        Buffer.alloc(128 * 1024, 0x61),
+      ),
+    ).toBe(true);
   } finally {
     await reader.close();
     reads.mockRestore();
@@ -205,3 +216,8 @@ it("reports impossible over-cap component extents as malformed", async () => {
     await reader.close();
   }
 });
+
+artifactPreparationRecoveryCases({
+  image: () => buildUImage({ payload: Buffer.from("payload") }),
+  createReader: (path, admitted) => new UImageArtifactReader(path, admitted),
+});

src/artifacts/UImageArtifactReader.ts

@@ -8,7 +8,10 @@ import type {
   UImageMetadata,
 } from "../domain/artifactFormatMetadata.js";
 import { ArtifactFileSource } from "./ArtifactFileSource.js";
-import { assertArtifactReadActive } from "./ArtifactFileOperation.js";
+import {
+  artifactReadCancelledBy,
+  assertArtifactReadActive,
+} from "./ArtifactFileOperation.js";
 import {
   ArtifactReaderFailure,
   copyArtifactEntry,
@@ -47,7 +50,9 @@ export class UImageArtifactReader implements ArtifactReader {
   readonly #entries = new Map<string, UImageEntry>();
   readonly #streams = new Set<Readable>();
   readonly #source: ArtifactFileSource;
-  #prepared: Promise<void> | undefined;
+  #prepared:
+    | { signal: AbortSignal | undefined; promise: Promise<void> }
+    | undefined;
   #header: UImageMetadata | undefined;
   #closing = false;
 
@@ -75,8 +80,27 @@ export class UImageArtifactReader implements ArtifactReader {
   ): AsyncIterable<ArtifactEntry> {
     await this.#scope.run(async () => {
       this.#assertOpen(signal);
-      this.#prepared ??= this.#prepare(signal);
-      await this.#prepared;
+      for (;;) {
+        const pending = (this.#prepared ??= {
+          signal,
+          promise: this.#prepare(signal),
+        });
+        try {
+          await pending.promise;
+          break;
+        } catch (cause: unknown) {
+          if (this.#prepared === pending) this.#prepared = undefined;
+          if (
+            pending.signal !== signal &&
+            signal?.aborted !== true &&
+            artifactReadCancelledBy(cause, pending.signal)
+          ) {
+            this.#assertOpen(signal);
+            continue;
+          }
+          throw cause;
+        }
+      }
       await this.#source.read(signal);
     });
     this.#assertOpen(signal);

src/artifacts/UnityFsArtifactReader.boundaries.test.ts

@@ -1,3 +1,5 @@
+import { artifactPreparationRecoveryCases } from "../../tests/fixtures/artifactReaderLifecycle.js";
+import { ArtifactFileSource } from "./ArtifactFileSource.js";
 import { truncate, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { buffer, text } from "node:stream/consumers";
@@ -43,6 +45,68 @@ const repeatedBlock = (data: Buffer): Buffer => {
   ]);
 };
 
+it("retries UnityFs preparation cancelled during file reading", async () => {
+  const path = await fixture(buildUnityFs([{ path: "a", data: "x" }]));
+  const admitted = await openRegularFile(path, { symlinks: "reject" });
+  const reader = new UnityFsArtifactReader(path, admitted);
+  const controller = new AbortController();
+  const reason = { stage: "header read" };
+  const nativeRead = admitted.handle.read.bind(admitted.handle);
+  const read = vi.spyOn(admitted.handle, "read").mockImplementation((async (
+    ...args: unknown[]
+  ) => {
+    const result = await Reflect.apply(nativeRead, admitted.handle, args);
+    controller.abort(reason);
+    return result;
+  }) as typeof admitted.handle.read);
+  try {
+    await expect(
+      (async () => {
+        for await (const _ of reader.entries(controller.signal)) {
+        }
+      })(),
+    ).rejects.toMatchObject({ reason: "cancelled", cause: reason });
+    read.mockRestore();
+    expect((await entries(reader)).map((entry) => entry.path)).toEqual(["a"]);
+  } finally {
+    read.mockRestore();
+    await reader.close();
+    await admitted.handle.close();
+  }
+});
+
+it("does not publish UnityFs entries when final source verification fails", async () => {
+  const path = await fixture(buildUnityFs([{ path: "a", data: "x" }]));
+  const control = new UnityFsArtifactReader(path);
+  const reader = new UnityFsArtifactReader(path);
+  const expected = (await entries(control))[0]!;
+  const nativeRead = ArtifactFileSource.prototype.read;
+  const physical = Object.assign(
+    new Error("final source verification failed"),
+    { code: "EIO" },
+  );
+  let calls = 0;
+  const read = vi
+    .spyOn(ArtifactFileSource.prototype, "read")
+    .mockImplementation(function (this: ArtifactFileSource, ...args) {
+      calls += 1;
+      if (calls === 2) return Promise.reject(physical);
+      return nativeRead.apply(this, args);
+    });
+  try {
+    await expect(entries(reader)).rejects.toBe(physical);
+    await expect(reader.open(expected)).rejects.toMatchObject({
+      reason: "integrity",
+    });
+    read.mockRestore();
+    expect((await entries(reader)).map((entry) => entry.path)).toEqual(["a"]);
+  } finally {
+    read.mockRestore();
+    await reader.close();
+    await control.close();
+  }
+});
+
 describe("UnityFS allocation and malformed-input boundaries", () => {
   it("rejects an oversized directory extending past the physical file", async () => {
     const bytes = buildUnityFs([{ path: "data", data: "x" }]);
@@ -431,3 +495,8 @@ describe("UnityFS stream capacity and cache ownership", () => {
     }
   });
 });
+
+artifactPreparationRecoveryCases({
+  image: () => buildUnityFs([{ path: "a", data: "x" }]),
+  createReader: (path, admitted) => new UnityFsArtifactReader(path, admitted),
+});

src/artifacts/UnityFsArtifactReader.ts

@@ -12,7 +12,10 @@ import {
   type ArtifactTraversalOptions,
 } from "./ArtifactReader.js";
 import { ArtifactResourceScope } from "./ArtifactResourceScope.js";
-import { assertArtifactReadActive } from "./ArtifactFileOperation.js";
+import {
+  artifactReadCancelledBy,
+  assertArtifactReadActive,
+} from "./ArtifactFileOperation.js";
 import { readArtifactFileBytes } from "./ArtifactFileRange.js";
 import type {
   ArtifactFormatMetadata,
@@ -52,10 +55,12 @@ interface UnityFsEntryState {
 export class UnityFsArtifactReader implements ArtifactReader {
   readonly format = "unityfs" as const;
   readonly #scope = new ArtifactResourceScope();
-  readonly #entries = new Map<string, UnityFsEntryState>();
+  #entries = new Map<string, UnityFsEntryState>();
   readonly #streams = new Map<Readable, AbortController>();
   readonly #source: ArtifactFileSource;
-  #prepared: Promise<void> | undefined;
+  #prepared:
+    | { signal: AbortSignal | undefined; promise: Promise<void> }
+    | undefined;
   #header: UnityFsMetadata | undefined;
   #blocks: readonly UnityFsBlock[] = [];
   #dataStart = 0;
@@ -88,8 +93,27 @@ export class UnityFsArtifactReader implements ArtifactReader {
   ): AsyncIterable<ArtifactEntry> {
     await this.#scope.run(async () => {
       this.#assertOpen(signal);
-      this.#prepared ??= this.#prepare(signal);
-      await this.#prepared;
+      for (;;) {
+        const pending = (this.#prepared ??= {
+          signal,
+          promise: this.#prepare(signal),
+        });
+        try {
+          await pending.promise;
+          break;
+        } catch (cause: unknown) {
+          if (this.#prepared === pending) this.#prepared = undefined;
+          if (
+            pending.signal !== signal &&
+            signal?.aborted !== true &&
+            artifactReadCancelledBy(cause, pending.signal)
+          ) {
+            this.#assertOpen(signal);
+            continue;
+          }
+          throw cause;
+        }
+      }
       await this.#source.read(signal);
     });
     this.#assertOpen(signal);
@@ -229,7 +253,7 @@ export class UnityFsArtifactReader implements ArtifactReader {
     if (header === undefined)
       throw unityFsFormatFailure("no complete UnityFS header");
     const status = header.layout.status;
-    this.#header = {
+    const metadata: UnityFsMetadata = {
       kind: "unityfs",
       signature: "UnityFS",
       format_version: header.formatVersion,
@@ -245,7 +269,12 @@ export class UnityFsArtifactReader implements ArtifactReader {
       data_hash: null,
       directory_status: status,
     };
-    if (status !== "available") return;
+    if (status !== "available") {
+      await this.#source.read(signal);
+      this.#assertOpen(signal);
+      this.#header = metadata;
+      return;
+    }
     const { dataHash, blocks, nodes, dataStart } = await readUnityFsBlocksInfo(
       handle,
       header,
@@ -259,44 +288,55 @@ export class UnityFsArtifactReader implements ArtifactReader {
       if (streamBytes > BigInt(budget))
         throw expansionLimit("declared virtual stream", streamBytes, budget);
     }
-    this.#header = {
-      ...this.#header,
+    const preparedMetadata: UnityFsMetadata = {
+      ...metadata,
       data_hash: dataHash,
       block_count: blocks.length,
       data_start: dataStart,
     };
-    this.#dataStart = dataStart;
     // Keep the source block count above, but do not revisit zero-output rows
     // for every member. Parsed stream/compressed offsets remain authoritative.
-    this.#blocks = blocks.filter((block) => block.uncompressedSize > 0);
-    this.#remainingDecodeBytes = budget;
-    await this.#registerNodes(nodes, budget, signal);
+    const readableBlocks = blocks.filter((block) => block.uncompressedSize > 0);
+    const registered = await this.#registerNodes(
+      nodes,
+      readableBlocks,
+      budget,
+      signal,
+    );
     await this.#source.read(signal);
+    this.#assertOpen(signal);
+    this.#header = preparedMetadata;
+    this.#dataStart = dataStart;
+    this.#blocks = readableBlocks;
+    this.#remainingDecodeBytes = budget;
+    this.#entries = registered.entries;
+    this.#remainingReadOperations = registered.remainingReadOperations;
   }
 
   async #registerNodes(
     nodes: readonly UnityFsNode[],
+    blocks: readonly UnityFsBlock[],
     budget: number,
     signal?: AbortSignal,
-  ): Promise<void> {
+  ): Promise<{
+    entries: Map<string, UnityFsEntryState>;
+    remainingReadOperations: number;
+  }> {
+    const entries = new Map<string, UnityFsEntryState>();
     let readableBytes = 0n;
     for (let index = 0; index < nodes.length; index++) {
       if (index % 256 === 0) await setImmediate();
       this.#assertOpen(signal);
       const node = nodes[index]!;
       const firstBlock =
-        node.size === 0 ? -1 : blockEndingAfter(this.#blocks, node.offset);
+        node.size === 0 ? -1 : blockEndingAfter(blocks, node.offset);
       const lastBlock =
         node.size === 0
           ? -1
-          : blockEndingAfter(this.#blocks, node.offset + node.size - 1);
+          : blockEndingAfter(blocks, node.offset + node.size - 1);
       if (node.size !== 0 && (firstBlock < 0 || lastBlock < firstBlock))
         throw unityFsFormatFailure("member has no block range");
-      const unavailable = firstUnavailableBlock(
-        this.#blocks,
-        firstBlock,
-        lastBlock,
-      );
+      const unavailable = firstUnavailableBlock(blocks, firstBlock, lastBlock);
       const kind =
         (node.flags & 1) !== 0 ? ("directory" as const) : ("file" as const);
       if (kind === "file" && unavailable === undefined) {
@@ -331,7 +371,7 @@ export class UnityFsArtifactReader implements ArtifactReader {
           flags: node.flags,
         },
       } satisfies UnityFsEntry;
-      this.#entries.set(adapterKey, {
+      entries.set(adapterKey, {
         entry,
         firstBlock,
         lastBlock,
@@ -340,14 +380,15 @@ export class UnityFsArtifactReader implements ArtifactReader {
     }
     // Four ordinary passes over admitted blocks, nodes and plaintext chunks,
     // with a small-reader floor. Byte quotas alone cannot bound tiny-block I/O.
-    this.#remainingReadOperations =
+    const remainingReadOperations =
       4 *
       Math.max(
         1024,
-        this.#blocks.length +
+        blocks.length +
           nodes.length +
           Math.ceil(Number(readableBytes) / CHUNK_BYTES),
       );
+    return { entries, remainingReadOperations };
   }
 
   async *#memberChunks(

src/artifacts/WxapkgArtifactReader.boundaries.test.ts

@@ -1,3 +1,5 @@
+import { artifactPreparationRecoveryCases } from "../../tests/fixtures/artifactReaderLifecycle.js";
+import { ArtifactFileSource } from "./ArtifactFileSource.js";
 import { once } from "node:events";
 import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
@@ -26,6 +28,68 @@ const entries = async (reader: WxapkgArtifactReader) => {
   return result;
 };
 
+it("retries Wxapkg preparation cancelled during file reading", async () => {
+  const path = await fixture(buildWxapkg([{ path: "a", data: "x" }]));
+  const admitted = await openRegularFile(path, { symlinks: "reject" });
+  const reader = new WxapkgArtifactReader(path, admitted);
+  const controller = new AbortController();
+  const reason = { stage: "header read" };
+  const nativeRead = admitted.handle.read.bind(admitted.handle);
+  const read = vi.spyOn(admitted.handle, "read").mockImplementation((async (
+    ...args: unknown[]
+  ) => {
+    const result = await Reflect.apply(nativeRead, admitted.handle, args);
+    controller.abort(reason);
+    return result;
+  }) as typeof admitted.handle.read);
+  try {
+    await expect(
+      (async () => {
+        for await (const _ of reader.entries(controller.signal)) {
+        }
+      })(),
+    ).rejects.toMatchObject({ reason: "cancelled", cause: reason });
+    read.mockRestore();
+    expect((await entries(reader)).map((entry) => entry.path)).toEqual(["a"]);
+  } finally {
+    read.mockRestore();
+    await reader.close();
+    await admitted.handle.close();
+  }
+});
+
+it("does not publish Wxapkg entries when final source verification fails", async () => {
+  const path = await fixture(buildWxapkg([{ path: "a", data: "x" }]));
+  const control = new WxapkgArtifactReader(path);
+  const reader = new WxapkgArtifactReader(path);
+  const expected = (await entries(control))[0]!;
+  const nativeRead = ArtifactFileSource.prototype.read;
+  const physical = Object.assign(
+    new Error("final source verification failed"),
+    { code: "EIO" },
+  );
+  let calls = 0;
+  const read = vi
+    .spyOn(ArtifactFileSource.prototype, "read")
+    .mockImplementation(function (this: ArtifactFileSource, ...args) {
+      calls += 1;
+      if (calls === 2) return Promise.reject(physical);
+      return nativeRead.apply(this, args);
+    });
+  try {
+    await expect(entries(reader)).rejects.toBe(physical);
+    await expect(reader.open(expected)).rejects.toMatchObject({
+      reason: "integrity",
+    });
+    read.mockRestore();
+    expect((await entries(reader)).map((entry) => entry.path)).toEqual(["a"]);
+  } finally {
+    read.mockRestore();
+    await reader.close();
+    await control.close();
+  }
+});
+
 describe("wxapkg allocation and malformed-input boundaries", () => {
   it("admits the encoded table budget before reading it", async () => {
     const bytes = buildWxapkg([{ path: "a", data: "x" }]);
@@ -308,3 +372,8 @@ describe("wxapkg stream capacity and freshness", () => {
     }
   });
 });
+
+artifactPreparationRecoveryCases({
+  image: () => buildWxapkg([{ path: "a", data: "x" }]),
+  createReader: (path, admitted) => new WxapkgArtifactReader(path, admitted),
+});

src/artifacts/WxapkgArtifactReader.ts

@@ -12,7 +12,10 @@ import {
   type ArtifactTraversalOptions,
 } from "./ArtifactReader.js";
 import { ArtifactResourceScope } from "./ArtifactResourceScope.js";
-import { assertArtifactReadActive } from "./ArtifactFileOperation.js";
+import {
+  artifactReadCancelledBy,
+  assertArtifactReadActive,
+} from "./ArtifactFileOperation.js";
 import { readArtifactFileBytes } from "./ArtifactFileRange.js";
 import type {
   ArtifactFormatMetadata,
@@ -48,10 +51,12 @@ interface WxapkgEntryState {
 export class WxapkgArtifactReader implements ArtifactReader {
   readonly format = "wxapkg" as const;
   readonly #scope = new ArtifactResourceScope();
-  readonly #entries = new Map<string, WxapkgEntryState>();
+  #entries = new Map<string, WxapkgEntryState>();
   readonly #streams = new Map<Readable, AbortController>();
   readonly #source: ArtifactFileSource;
-  #prepared: Promise<void> | undefined;
+  #prepared:
+    | { signal: AbortSignal | undefined; promise: Promise<void> }
+    | undefined;
   #header: WxapkgMetadata | undefined;
   #remainingReadOperations = 0;
   #admittedReadOperations = 0;
@@ -81,8 +86,27 @@ export class WxapkgArtifactReader implements ArtifactReader {
   ): AsyncIterable<ArtifactEntry> {
     await this.#scope.run(async () => {
       this.#assertOpen(signal);
-      this.#prepared ??= this.#prepare(signal);
-      await this.#prepared;
+      for (;;) {
+        const pending = (this.#prepared ??= {
+          signal,
+          promise: this.#prepare(signal),
+        });
+        try {
+          await pending.promise;
+          break;
+        } catch (cause: unknown) {
+          if (this.#prepared === pending) this.#prepared = undefined;
+          if (
+            pending.signal !== signal &&
+            signal?.aborted !== true &&
+            artifactReadCancelledBy(cause, pending.signal)
+          ) {
+            this.#assertOpen(signal);
+            continue;
+          }
+          throw cause;
+        }
+      }
       await this.#source.read(signal);
     });
     this.#assertOpen(signal);
@@ -201,7 +225,7 @@ export class WxapkgArtifactReader implements ArtifactReader {
     const header = await readWxapkgHeader(handle, initial.size, signal);
     if (header === undefined)
       throw wxapkgFormatFailure("no complete wxapkg header");
-    this.#header = {
+    const metadata: WxapkgMetadata = {
       kind: "wxapkg",
       info: header.layout.status === "available" ? header.info : null,
       index_length:
@@ -212,7 +236,12 @@ export class WxapkgArtifactReader implements ArtifactReader {
         header.layout.status === "available" ? header.fileCount : null,
       directory_status: header.layout.status,
     };
-    if (header.layout.status !== "available") return;
+    if (header.layout.status !== "available") {
+      await this.#source.read(signal);
+      this.#assertOpen(signal);
+      this.#header = metadata;
+      return;
+    }
     const { members } = await readWxapkgFileTable(
       handle,
       header,
@@ -220,6 +249,7 @@ export class WxapkgArtifactReader implements ArtifactReader {
       signal,
     );
     const budget = artifactExpansionBudgetBytes(initial.size);
+    const entries = new Map<string, WxapkgEntryState>();
     let declaredBytes = 0n;
     for (let index = 0; index < members.length; index++) {
       if (index % 256 === 0) await setImmediate();
@@ -234,7 +264,7 @@ export class WxapkgArtifactReader implements ArtifactReader {
           { boundary: "memory" },
         );
       const adapterKey = `wxapkg-entry:${String(index)}`;
-      this.#entries.set(adapterKey, {
+      entries.set(adapterKey, {
         entry: {
           path: member.path,
           sourcePath: member.declaredPath,
@@ -260,14 +290,18 @@ export class WxapkgArtifactReader implements ArtifactReader {
       });
     }
     // Header, table and per-chunk member reads; a small-reader floor applies.
-    this.#admittedReadOperations =
+    const admittedReadOperations =
       4 *
       Math.max(
         1024,
         members.length + Math.ceil(Number(declaredBytes) / CHUNK_BYTES),
       );
-    this.#remainingReadOperations = this.#admittedReadOperations;
     await this.#source.read(signal);
+    this.#assertOpen(signal);
+    this.#header = metadata;
+    this.#entries = entries;
+    this.#admittedReadOperations = admittedReadOperations;
+    this.#remainingReadOperations = admittedReadOperations;
   }
 
   async *#memberChunks(

src/artifacts/apple/MachoEncryptionReader.test.ts

@@ -132,6 +132,7 @@ describe("Mach-O encryption reader: thin images", () => {
       container_file_offset: 0,
       size: expect.any(Number),
       status: "absent",
+      malformed_kind: null,
       reason: null,
       commands: [],
       range: null,
@@ -479,6 +480,27 @@ describe("Mach-O encryption reader: segment VM extent", () => {
 });
 
 describe("Mach-O encryption reader: defects are never absent", () => {
+  it.each([0, 1, 2])(
+    "keeps a structural encryption defect at index %i ahead of duplicate ambiguity",
+    async (index) => {
+      const commands = Array.from({ length: 3 }, () =>
+        encryption({ cryptoff: 0, cryptsize: 0, cryptid: 1 }),
+      );
+      commands[index] = encryption(
+        { cryptoff: 0, cryptsize: 0, cryptid: 1 },
+        true,
+        8,
+      );
+      const slice = await onlySlice(machoImage({ commands }));
+      expect(slice).toMatchObject({
+        status: "malformed",
+        malformed_kind: "structure",
+        reason: `slice has 3 encryption load commands; load command ${index} LC_ENCRYPTION_INFO_64 has cmdsize 8, expected 24`,
+        range: null,
+      });
+      expect(slice.commands.map(({ index }) => index)).toEqual([0, 1]);
+    },
+  );
   it.each([
     {
       name: "a 64-bit command in a 32-bit image",
@@ -544,6 +566,7 @@ describe("Mach-O encryption reader: defects are never absent", () => {
     expect(slice).toMatchObject({
       status: "malformed",
       reason: "slice has 1000 encryption load commands",
+      malformed_kind: "duplicate-commands",
       range: null,
     });
     expect(slice.commands.map(({ index }) => index)).toEqual([0, 1]);

src/artifacts/apple/MachoEncryptionReader.ts

@@ -117,6 +117,7 @@ const unread = (
   container_file_offset: declaration.offset,
   size: declaration.size,
   status,
+  malformed_kind: status === "malformed" ? "structure" : null,
   reason,
   commands: [],
   range: null,
@@ -143,6 +144,10 @@ const readSlice = async (
   // and dropped so a large table of small commands stays one buffer.
   const commands: MachoEncryptionCommand[] = [];
   let encryptionCommands = 0;
+  const encryption: {
+    first: ValidEncryptionCommand | null;
+    failure: string | null;
+  } = { first: null, failure: null };
   // Null once this slice's segments need more records than the shared
   // mapping budget has left; none are retained past that point.
   let segments: MachoLoadCommand[] | null = [];
@@ -155,6 +160,7 @@ const readSlice = async (
   }: MachoReadIssue): MachoSliceEncryption => ({
     ...base,
     status: status === "unsupported" ? "unknown" : "malformed",
+    malformed_kind: status === "unsupported" ? null : "structure",
     reason,
     commands,
     range: null,
@@ -164,8 +170,12 @@ const readSlice = async (
   const framed = frameLoadCommands(table, (command) => {
     if (isEncryptionCommand(command.command)) {
       encryptionCommands += 1;
+      const decoded = decodeEncryptionCommand(command);
       if (commands.length < RETAINED_ENCRYPTION_COMMANDS)
-        commands.push(decodeEncryptionCommand(command));
+        commands.push(decoded);
+      const checked = classifyCommand(decoded, header, slice.size);
+      if (checked.status === "malformed") encryption.failure ??= checked.reason;
+      else encryption.first ??= checked.command;
     } else if (
       segments !== null &&
       (command.command === LC_SEGMENT || command.command === LC_SEGMENT_64)
@@ -187,15 +197,44 @@ const readSlice = async (
     return {
       ...base,
       status: "malformed",
+      malformed_kind: "structure",
       reason: identityIssue,
       commands,
       range: null,
     };
-  const outcome = classify(commands, encryptionCommands, header, slice.size);
-  if (outcome.status !== "valid")
-    return { ...base, ...outcome, commands, range: null };
+  if (encryption.failure !== null)
+    return {
+      ...base,
+      status: "malformed",
+      malformed_kind: "structure",
+      reason:
+        encryptionCommands > 1
+          ? `slice has ${encryptionCommands} encryption load commands; ${encryption.failure}`
+          : encryption.failure,
+      commands,
+      range: null,
+    };
+  if (encryptionCommands > 1)
+    return {
+      ...base,
+      status: "malformed",
+      malformed_kind: "duplicate-commands",
+      reason: `slice has ${encryptionCommands} encryption load commands`,
+      commands,
+      range: null,
+    };
+  const command = encryption.first;
+  if (command === null)
+    return {
+      ...base,
+      status: "absent",
+      malformed_kind: null,
+      reason: null,
+      commands,
+      range: null,
+    };
   const range = encryptedRange(
-    outcome.command,
+    command,
     header,
     segments,
     slice.offset,
@@ -206,7 +245,8 @@ const readSlice = async (
   if (range.mapping.status === "mapped") budget.remaining -= segmentRecords;
   return {
     ...base,
-    status: outcome.command.cryptid === 0 ? "not-encrypted" : "encrypted",
+    status: command.cryptid === 0 ? "not-encrypted" : "encrypted",
+    malformed_kind: null,
     reason: null,
     commands,
     range,
@@ -236,31 +276,23 @@ const decodeEncryptionCommand = ({
   };
 };
 
+type ValidEncryptionCommand = MachoEncryptionCommand & {
+  readonly cryptoff: number;
+  readonly cryptsize: number;
+  readonly cryptid: number;
+};
 type Classification =
   | {
       readonly status: "valid";
-      readonly command: MachoEncryptionCommand & {
-        readonly cryptoff: number;
-        readonly cryptsize: number;
-        readonly cryptid: number;
-      };
+      readonly command: ValidEncryptionCommand;
     }
-  | { readonly status: "absent"; readonly reason: null }
   | { readonly status: "malformed"; readonly reason: string };
 
-const classify = (
-  commands: readonly MachoEncryptionCommand[],
-  count: number,
+const classifyCommand = (
+  command: MachoEncryptionCommand,
   header: MachoSliceHeader,
   sliceSize: number,
 ): Classification => {
-  if (count === 0) return { status: "absent", reason: null };
-  const [command] = commands;
-  if (command === undefined || count > 1)
-    return {
-      status: "malformed",
-      reason: `slice has ${count} encryption load commands`,
-    };
   const width = header.wide ? 64 : 32;
   const expectedKind = header.wide
     ? "LC_ENCRYPTION_INFO_64"

src/artifacts/artifactFormats.test.ts

@@ -43,7 +43,8 @@ type FormatsWithReaders =
   | "uf2"
   | "dfuse"
   | "esp-flash-image"
-  | "fit";
+  | "fit"
+  | "ntfs-mft";
 
 const readerFormatsMatch: Equal<ArtifactReaderFormat, FormatsWithReaders> =
   true;

src/artifacts/artifactFormats.ts

@@ -40,6 +40,7 @@ import { NodeSeaArtifactReader } from "./NodeSeaArtifactReader.js";
 import type { PyInstallerAdmission } from "./pyinstaller/PyInstallerAdmission.js";
 import { PyInstallerArtifactReader } from "./PyInstallerArtifactReader.js";
 import { Uf2ArtifactReader } from "./Uf2ArtifactReader.js";
+import { NtfsMftArtifactReader } from "./NtfsMftArtifactReader.js";
 import { UImageArtifactReader } from "./UImageArtifactReader.js";
 import { UnityFsArtifactReader } from "./UnityFsArtifactReader.js";
 import { WxapkgArtifactReader } from "./WxapkgArtifactReader.js";
@@ -465,6 +466,14 @@ const NON_ZIP_FORMATS = {
     createReader: (path, options) =>
       new FitArtifactReader(path, sourceOf(options)),
   }),
+  "ntfs-mft": described("ntfs-mft", {
+    ...plain,
+    retainClassifiedSource: true,
+    readerLimitation:
+      "MFT inventory reports whole-stream counts and a bounded sample of the first 32 decoded FILE record headers, with the omitted-header count. Attributes, filenames, data streams and the $UsnJrnl:$J journal are not decoded, so no path, file size or change history is established.",
+    createReader: (path, options) =>
+      new NtfsMftArtifactReader(path, sourceOf(options)),
+  }),
   unknown: described("unknown", plain),
 } satisfies Record<
   Exclude<ArtifactFormatId, ZipPackageFormat>,

src/artifacts/inventory/ArtifactGraphConstruction.test.ts

@@ -576,6 +576,28 @@ it("classifies nested UF2 by block magics and DfuSe by prefix and suffix", () =>
   ).toMatchObject({ format: "file" });
 });
 
+it("classifies a $MFT stream by its FILE record header, under any name", () => {
+  const mft = Buffer.alloc(2_048);
+  mft.write("FILE", 0, "latin1");
+  mft.writeUInt32LE(1024, 28);
+  for (const path of ["evidence/$MFT", "evidence/mft.raw", "evidence/records"])
+    expect(classifyArtifactBytesAtPath(path, mft)).toEqual({
+      kind: "executable",
+      format: "ntfs-mft",
+    });
+});
+
+it("leaves plain content beginning with FILE unclassified as MFT", () => {
+  const text = Buffer.from(
+    "FILE is a plain text prefix, not an NTFS record header",
+  );
+  expect(
+    classifyArtifactBytesAtPath("evidence/readme.txt", text),
+  ).toMatchObject({
+    format: "file",
+  });
+});
+
 it("classifies a FIT by a /images node within the first 4 KiB", () => {
   const images = [{ name: "kernel", data: Buffer.from("kernel") }];
   const late = devicetreeFixture({

src/artifacts/inventory/ArtifactGraphConstruction.ts

@@ -11,6 +11,7 @@ import { recognizeEspImage } from "../../domain/firmware/espImage.js";
 import { hasUf2Block } from "../../domain/firmware/uf2.js";
 import { isDfuSeFile } from "../../domain/firmware/dfuse.js";
 import { hasFitImagesNode } from "../../domain/firmware/fitImage.js";
+import { hasMftFileRecordHeader } from "../../domain/windows/ntfsMft.js";
 import type { ArtifactClassificationEvidence } from "../ArtifactClassificationProbe.js";
 import { asarHeaderAdmissionFailure } from "../AsarHeader.js";
 import { hasDestinationPath } from "../ArtifactPaths.js";
@@ -622,6 +623,7 @@ export const classifyArtifactBytes = (
     return "dfuse";
   if (recognizeEspImage(prefix, fileSize) === "esp-image") return "esp-image";
   if (hasFitImagesNode(prefix)) return "fit";
+  if (hasMftFileRecordHeader(prefix)) return "ntfs-mft";
   if (hasBinaryPlistSignature(prefix)) return "plist";
   if (hasXmlPlistSignature(prefix)) return "plist";
   const fatFormat = classifyFatArtifact(evidence, fileSize);

src/domain/analysisSnapshot.ts

@@ -86,6 +86,7 @@ const formatSchema = z.enum([
   "dfuse",
   "esp-flash-image",
   "fit",
+  "ntfs-mft",
   "plist",
   "javascript",
   "source-map",

src/domain/analysisView/machoView.test.ts

@@ -68,6 +68,42 @@ it("keeps historical symbol defaults scoped to their selected Mach-O facet", ()
   ).toBe(false);
 });
 
+it.each(["not-encrypted", "malformed"] as const)(
+  "projects historical encryption rows with %s status",
+  (status) => {
+    const current = inspectMachoSchema.parse(report);
+    const { malformed_kind: _unrecorded, ...recorded } =
+      current.encryption.items[0]!;
+    const historical = {
+      ...recorded,
+      status,
+      ...(status === "malformed"
+        ? { reason: "slice has 3 encryption load commands", range: null }
+        : {}),
+    };
+    const source = { ...current, encryption: coverage([historical]) };
+    expect(inspectMachoSchema.safeParse(source).success).toBe(false);
+    const projected = projectAnalysisView(parent(source), {
+      kind: "macho",
+      facet: "encryption",
+      offset: 0,
+      limit: 10,
+    });
+    if (!projected.ok || projected.value.kind !== "macho")
+      throw new Error("Expected a historical Mach-O encryption page");
+    expect(projected.value.item).toEqual([
+      {
+        ...historical,
+        malformed_kind: status === "malformed" ? "unrecorded" : null,
+      },
+    ]);
+    expect(analysisViewResultSchema.safeParse(projected.value).success).toBe(
+      true,
+    );
+    expect(historical).not.toHaveProperty("malformed_kind");
+  },
+);
+
 const symbol = (name: string) => ({
   name,
   runtime_name: name.slice(1),
@@ -148,6 +184,7 @@ const report = {
       container_file_offset: 0,
       size: 4096,
       status: "not-encrypted",
+      malformed_kind: null,
       reason: null,
       commands: [
         {

src/domain/analysisView/machoView.ts

@@ -3,6 +3,7 @@ import { z } from "zod";
 import type { AnalysisError } from "../analysisErrorBase.js";
 import { uniqueSorted } from "../canonicalOrdering.js";
 import { isMachOFormat } from "../binaryTargetTypes.js";
+import { machoSliceEncryptionViewSchema } from "../apple/machoEncryption.js";
 import {
   inspectMachoSchema,
   retainedInspectMachoSchema,
@@ -56,7 +57,7 @@ export const machoViewRows = {
   imports: exactRows(shape.imports.shape.items),
   exports: exactRows(shape.exports.shape.items),
   segments: exactRows(shape.segments.shape.items),
-  encryption: exactRows(shape.encryption.shape.items),
+  encryption: z.array(machoSliceEncryptionViewSchema),
   provenance: exactRows(shape.provenance),
 };
 
@@ -90,7 +91,7 @@ export const machoSummarySchema = z.strictObject({
   limitation_count: z.int().nonnegative(),
 });
 
-type MachoReport = z.output<typeof inspectMachoSchema>;
+type MachoReport = z.output<typeof retainedInspectMachoSchema>;
 
 /** Admit a well-formed report whose recorded subject, if any, is a Mach-O. */
 const parseMachoReport = (

src/domain/apple/dyldPaths.ts

@@ -77,7 +77,10 @@ export const directoryOf = (path: string): string => {
 export const joinPath = (directory: string, rest: string): string =>
   directory === "" ? rest : rest === "" ? directory : `${directory}/${rest}`;
 
-export type Expansion =
+export type Expansion = {
+  /** Recognized dyld token, owned by the same parse that expands the path. */
+  readonly prefix?: "loader_path" | "executable_path";
+} & (
   | {
       readonly scope: "target";
       /** Source-facing expansion retained in candidate Evidence. */
@@ -86,7 +89,8 @@ export type Expansion =
       readonly lookupPath?: string;
     }
   | { readonly scope: "outside"; readonly path: string }
-  | { readonly scope: "undetermined"; readonly path: string };
+  | { readonly scope: "undetermined"; readonly path: string }
+);
 
 /** Expand one dyld path prefix relative to its owning image. */
 export const expandPrefix = (
@@ -102,12 +106,17 @@ export const expandPrefix = (
   if (variable !== null) {
     const rest = variable[2] ?? "";
     if (variable[1] === "loader_path")
-      return { scope: "target", path: joinPath(context.ownerDirectory, rest) };
+      return {
+        scope: "target",
+        path: joinPath(context.ownerDirectory, rest),
+        prefix: "loader_path",
+      };
     return context.executable === null
-      ? { scope: "undetermined", path: raw }
+      ? { scope: "undetermined", path: raw, prefix: "executable_path" }
       : {
           scope: "target",
           path: joinPath(directoryOf(context.executable), rest),
+          prefix: "executable_path",
         };
   }
   if (raw.startsWith("/")) {

src/domain/apple/dylibResolution.test.ts

@@ -222,9 +222,9 @@ it.each(["@loader_path_suffix", "@executable_path_suffix", "@loader_path\n"])(
       }),
       { roots: [MAIN] },
     );
-    expect(edgeFor(trace, MAIN, name).resolution).toEqual({
-      status: "undetermined",
-      image: null,
+    expect(edgeFor(trace, MAIN, name)).toMatchObject({
+      candidates: [{ source: "literal", path: name }],
+      resolution: { status: "undetermined", image: null },
     });
   },
 );
@@ -1020,6 +1020,12 @@ describe("dyld slice compatibility and coverage", () => {
       ],
       resolution: { status: "undetermined", image: null },
     });
+    expect(trace.coverage.status).toBe("partial");
+    expect(trace.limitations).toContainEqual(
+      expect.stringContaining(
+        "Contents/MacOS/libarm.dylib have unknown architecture compatibility",
+      ),
+    );
   });
 
   it("lets an x86_64h process load generic x86_64 but not arm64e load arm64", async () => {

src/domain/apple/dylibResolution.ts

@@ -268,6 +268,7 @@ interface ProcessContext {
   >;
   readonly searchOverrides: readonly DyldSearchOverride[];
   readonly environmentRoots: Set<string>;
+  readonly unknownArchitectureCandidates: Set<string>;
   readonly unknownPlatformCandidates: Set<string>;
   readonly undecodableSymlinkTargets: Map<string, string>;
   readonly implicitMacOSPlatformCandidates: Set<string>;
@@ -310,15 +311,11 @@ const candidateTemplates = (
 ): CandidateTemplate[] => {
   const name = dependency.install_name;
   if (!name.startsWith("@rpath/")) {
-    const source = name.startsWith("@executable_path")
-      ? "executable_path"
-      : name.startsWith("@loader_path")
-        ? "loader_path"
-        : "literal";
+    const expansion = expandCandidatePath(name, directoryOf(loader), context);
     return [
       {
-        expansion: expandCandidatePath(name, directoryOf(loader), context),
-        source,
+        expansion,
+        source: expansion.prefix ?? "literal",
         rpath: null,
         rpathOwner: null,
       },
@@ -379,8 +376,10 @@ const evaluateCandidate = async (
       machoImageSlices(facts),
       context.processIdentity,
     );
-    if (selection.kind === "unknown") outcome = "undetermined";
-    else if (selection.kind === "missing") outcome = "architecture-missing";
+    if (selection.kind === "unknown") {
+      outcome = "undetermined";
+      context.unknownArchitectureCandidates.add(lookup.path);
+    } else if (selection.kind === "missing") outcome = "architecture-missing";
     // Dependency commands require a dylib; generic dyld image loadability
     // also admits main executables and bundles for different operations.
     else if (selection.slice.file_type_code !== 6) outcome = "not-loadable";
@@ -672,6 +671,7 @@ const projectTraceResult = (input: {
   readonly edges: readonly Edge[];
   readonly withoutArchitecture: readonly string[];
   readonly environmentRoots: ReadonlySet<string>;
+  readonly unknownArchitectureCandidates: ReadonlySet<string>;
   readonly unknownPlatformCandidates: ReadonlySet<string>;
   readonly undecodableSymlinkTargets: ReadonlyMap<string, string>;
   readonly implicitMacOSPlatformCandidates: ReadonlySet<string>;
@@ -705,6 +705,7 @@ const projectTraceResult = (input: {
         unparsed.length === 0 &&
         input.withoutArchitecture.length === 0 &&
         input.environmentRoots.size === 0 &&
+        input.unknownArchitectureCandidates.size === 0 &&
         input.unknownPlatformCandidates.size === 0 &&
         input.undecodableSymlinkTargets.size === 0 &&
         input.rootEnumeration?.status !== "unknown"
@@ -726,6 +727,11 @@ const projectTraceResult = (input: {
         : [
             `Roots ${[...input.environmentRoots].join(", ")} request applicable image-selection inputs through LC_DYLD_ENVIRONMENT that are not modeled; affected dependencies or inserted images remain uncertain.`,
           ]),
+      ...(input.unknownArchitectureCandidates.size === 0
+        ? []
+        : [
+            `In-root dylib candidates ${[...input.unknownArchitectureCandidates].sort(compare).join(", ")} have unknown architecture compatibility and are not treated as incompatible. Their dependent graphs may be incomplete.`,
+          ]),
       ...(input.unknownPlatformCandidates.size === 0
         ? []
         : [
@@ -760,6 +766,7 @@ export const traceDylibLoading = async (
   const edges: Edge[] = [];
   const withoutArchitecture: string[] = [];
   const environmentRoots = new Set<string>();
+  const unknownArchitectureCandidates = new Set<string>();
   const unknownPlatformCandidates = new Set<string>();
   const undecodableSymlinkTargets = new Map<string, string>();
   const implicitMacOSPlatformCandidates = new Set<string>();
@@ -802,6 +809,7 @@ export const traceDylibLoading = async (
             },
             searchOverrides,
             environmentRoots,
+            unknownArchitectureCandidates,
             unknownPlatformCandidates,
             undecodableSymlinkTargets,
             implicitMacOSPlatformCandidates,
@@ -824,6 +832,7 @@ export const traceDylibLoading = async (
     edges,
     withoutArchitecture,
     environmentRoots,
+    unknownArchitectureCandidates,
     unknownPlatformCandidates,
     undecodableSymlinkTargets,
     implicitMacOSPlatformCandidates,

src/domain/apple/dylibResolutionFindings.ts

@@ -164,7 +164,7 @@ const lazyConsequence = (weak: boolean): string =>
 export const DYLIB_RESOLUTION_LIMITATIONS = [
   "LC_LAZY_LOAD_DYLIB and LC_LAZY_LOAD_DYLIB_INFO dependencies are resolved but not traversed, because dyld loads them only on first use.",
   "Slices are matched by dyld's graded architectures (an x86_64h process also loads x86_64). arm64e processes that disable pointer authentication can also load arm64 slices; that fallback is not modeled.",
-  "Absolute install names and rpaths are outside the analyzed root and are not evaluated, including /System and /usr/lib libraries that the dyld shared cache usually provides.",
+  "Absolute install names and rpaths are evaluated only when spelled beneath the analyzed root. Other absolute paths remain outside the analyzed root, including /System and /usr/lib libraries that the dyld shared cache usually provides.",
   "Leaf and relative install names depend on dyld fallback paths, DYLD_* variables, and the working directory; they are undetermined.",
   "Load order follows dyld's dependents-first traversal in load-command order. An image reached through several chains is resolved once per process, with the rpath stack and conditionality of the first chain; a later @rpath request whose install name matches an already loaded image reuses it.",
   "@loader_path uses each image's symlink-resolved path within the analyzed root.",

src/domain/apple/machoEncryption.test.ts

@@ -0,0 +1,37 @@
+import { expect, it } from "vitest";
+import { machoSliceEncryptionSchema } from "./machoEncryption.js";
+
+it("requires a malformed cause exactly for malformed slice encryption", () => {
+  const slice = {
+    architecture: null,
+    cpu_type: null,
+    cpu_subtype: null,
+    container_file_offset: 0,
+    size: 32,
+    reason: null,
+    commands: [],
+    range: null,
+  };
+  for (const status of [
+    "absent",
+    "encrypted",
+    "not-encrypted",
+    "unknown",
+    "malformed",
+  ]) {
+    for (const malformed_kind of [null, "structure", "duplicate-commands"]) {
+      expect(
+        machoSliceEncryptionSchema.safeParse({
+          ...slice,
+          status,
+          malformed_kind,
+        }).success,
+        `${status}/${String(malformed_kind)}`,
+      ).toBe((status === "malformed") === (malformed_kind !== null));
+    }
+  }
+  expect(
+    machoSliceEncryptionSchema.safeParse({ ...slice, status: "absent" })
+      .success,
+  ).toBe(false);
+});

src/domain/apple/machoEncryption.ts

@@ -78,8 +78,15 @@ export const machoEncryptionStatusSchema = z.enum([
   "unknown",
 ]);
 
-/** Load-command encryption state of one Mach-O slice. */
-export const machoSliceEncryptionSchema = z.object({
+const malformedKinds = ["structure", "duplicate-commands"] as const;
+const malformedKind = z
+  .enum(malformedKinds)
+  .nullable()
+  .describe(
+    "Malformed cause owned by the structural reader; duplicate-commands means every encryption command was structurally valid. Null for all other statuses.",
+  );
+
+const sliceEncryptionFields = {
   architecture: z
     .string()
     .nullable()
@@ -93,14 +100,65 @@ export const machoSliceEncryptionSchema = z.object({
   status: machoEncryptionStatusSchema.describe(
     "absent only when every load command was read; malformed and unknown carry a reason.",
   ),
+  malformed_kind: malformedKind,
   reason: z.string().nullable(),
   commands: z
     .array(machoEncryptionCommandSchema)
     .describe(
-      "Encryption load commands in table order; a slice with more than two keeps the first two and states the count in reason.",
+      "Encryption load commands in table order; a completed slice with more than two keeps the first two and states the total count in reason. Structural failures identify the invalid command, including commands beyond the retained pair.",
     ),
   range: machoEncryptedRangeSchema.nullable(),
-});
+};
+
+const validateMalformedKind = (
+  slice: { status: string; malformed_kind?: string | null | undefined },
+  context: z.RefinementCtx,
+): void => {
+  if (
+    slice.malformed_kind !== undefined &&
+    (slice.status === "malformed") !== (slice.malformed_kind !== null)
+  )
+    context.addIssue({
+      code: "custom",
+      path: ["malformed_kind"],
+      message: "A malformed cause is required exactly when status is malformed",
+    });
+};
+
+/** Load-command encryption state of one newly inspected Mach-O slice. */
+export const machoSliceEncryptionSchema = z
+  .object(sliceEncryptionFields)
+  .superRefine(validateMalformedKind);
+
+/** View rows also report when a historical malformed cause was not recorded. */
+export const machoSliceEncryptionViewSchema = z
+  .strictObject({
+    ...sliceEncryptionFields,
+    malformed_kind: z
+      .enum([...malformedKinds, "unrecorded"])
+      .nullable()
+      .describe(
+        "Structural cause or duplicate-command ambiguity. Unrecorded means the historical inspection did not classify the cause. Null for other statuses.",
+      ),
+  })
+  .superRefine(validateMalformedKind);
+
+/** Interpret earlier slice records without inferring a cause from their command count. */
+export const retainedMachoSliceEncryptionSchema = z
+  .object({
+    ...sliceEncryptionFields,
+    malformed_kind: malformedKind.exactOptional(),
+  })
+  .superRefine(validateMalformedKind)
+  .transform((slice): z.output<typeof machoSliceEncryptionViewSchema> => ({
+    ...slice,
+    malformed_kind:
+      slice.malformed_kind === undefined
+        ? slice.status === "malformed"
+          ? "unrecorded"
+          : null
+        : slice.malformed_kind,
+  }));
 
 export type MachoEncryptionCommand = z.infer<
   typeof machoEncryptionCommandSchema

src/domain/artifactFormatMetadata.ts

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { MFT_INLINE_HEADER_LIMIT } from "./windows/ntfsMft.js";
 
 import { jsonRecordSchema } from "./jsonRecord.js";
 import { jsonValueSchema } from "./jsonValue.js";
@@ -299,6 +300,56 @@ export const hexRecordRegionMetadataSchema = z.strictObject({
   last_line: offset,
 });
 
+const ntfsFileReferenceSchema = z.strictObject({
+  recordNumber: offset,
+  sequenceNumber: offset,
+});
+const ntfsRecordHeaderSchema = z.strictObject({
+  index: offset,
+  fileOffset: offset,
+  sequenceNumber: offset,
+  hardLinkCount: offset,
+  flags: z.strictObject({
+    raw: offset,
+    names: z.array(z.string()),
+    unknownMask: offset,
+  }),
+  inUse: z.boolean(),
+  directory: z.boolean(),
+  usedBytes: offset,
+  totalBytes: offset,
+  extentValid: z.boolean(),
+  baseRecordReference: ntfsFileReferenceSchema.nullable(),
+  declaredRecordNumber: offset.nullable(),
+  recordNumberMatchesSlot: z.boolean().nullable(),
+  logFileSequenceNumber: z.string().regex(/^(?:0|[1-9][0-9]*)$/u),
+  firstAttributeOffset: offset,
+  nextAttributeId: offset,
+  fixups: z.strictObject({
+    sequenceNumber: offset,
+    entries: offset,
+    verifiedSectors: offset,
+    coveredSectors: offset,
+    mismatchSector: offset.nullable(),
+    malformed: z.boolean(),
+  }),
+});
+
+/** NTFS $MFT record-header facts; attributes, names and the USN journal are later steps. */
+export const ntfsMftMetadataSchema = z.strictObject({
+  kind: z.literal("ntfs-mft"),
+  record_bytes: offset,
+  record_count: offset,
+  in_use_record_count: offset,
+  directory_record_count: offset,
+  extension_record_count: offset,
+  fixup_mismatch_count: offset,
+  fixup_unverified_record_count: offset,
+  truncated_tail_bytes: offset,
+  record_headers: z.array(ntfsRecordHeaderSchema).max(MFT_INLINE_HEADER_LIMIT),
+  omitted_record_headers: offset,
+});
+
 /**
  * U-Boot FIT root facts. Configuration references are declared names; a
  * reference that names no image is reported as a limitation, not removed.
@@ -886,6 +937,7 @@ export const artifactFormatMetadataSchema = z.discriminatedUnion("kind", [
   espImageSignatureBlockMetadataSchema,
   uf2MetadataSchema,
   uf2RegionMetadataSchema,
+  ntfsMftMetadataSchema,
   dfuSeMetadataSchema,
   dfuSeElementMetadataSchema,
   espFlashImageMetadataSchema,
@@ -1036,6 +1088,10 @@ const declarationsByKind: {
     notCompared:
       "Its familyID and addresses are in its path, family_name is REA's label for the familyID, and its block counts and positions are layout; content comparison covers its bytes.",
   },
+  "ntfs-mft": {
+    notCompared:
+      "Its fields come from the record headers in the file's own FILE records, which content comparison covers.",
+  },
   dfuse: {
     notCompared:
       "Its fields come from the file's own prefix, target headers and suffix, which content comparison covers.",

src/domain/artifactGraph.ts

@@ -103,6 +103,7 @@ export const ARTIFACT_FORMAT_IDS = [
   "dfuse",
   "esp-flash-image",
   "fit",
+  "ntfs-mft",
   "unknown",
 ] as const;
 
@@ -124,6 +125,7 @@ const artifactContentFormatSchema = artifactFormatSchema.extract([
   "uf2",
   "dfuse",
   "fit",
+  "ntfs-mft",
   "mach-o-universal",
   "mach-o",
   "elf",

src/domain/binaryTargetTypes.ts

@@ -302,7 +302,8 @@ export type BinaryTarget =
           | "esp-image"
           | "uf2"
           | "dfuse"
-          | "fit";
+          | "fit"
+          | "ntfs-mft";
       })
   | (BinaryTargetIdentity &
       NonExecutableMetadata & {

src/domain/evidenceSubject.ts

@@ -52,6 +52,7 @@ export const evidenceSubjectFormatSchema = z.enum([
   "dfuse",
   "esp-flash-image",
   "fit",
+  "ntfs-mft",
 ]);
 
 /** Format-owned architecture declarations shared by Evidence and persisted executions. */

src/domain/javascript/childProcessOptionsRegression.test.ts

@@ -137,7 +137,8 @@ describe("child-process options detection", () => {
       ["negative-zero", `spawn("tool", [], { env: -0 })`, false],
       ["bigint-zero", `spawn("tool", [], { env: 0n })`, false],
       ["zero-float", `spawn("tool", [], { env: 0.0 })`, false],
-      ["nan", `spawn("tool", [], { env: NaN })`, true],
+      ["nan", `spawn("tool", [], { env: NaN })`, false],
+      ["shadowed-nan", `((NaN) => spawn("tool", [], { env: NaN }))({})`, true],
       ["empty-string", `spawn("tool", [], { env: "" })`, false],
       ["false", `spawn("tool", [], { env: false })`, false],
       ["empty-object", `spawn("tool", [], { env: {} })`, true],

src/domain/javascript/javascriptSemanticChildProcesses.ts

@@ -81,7 +81,7 @@ export const collectJavaScriptSemanticChildProcesses = (
       !rejectsOptionsShape(candidate, context, state),
   );
   const childProcessSpawns = candidates.map((candidate) =>
-    immutableSpawn(candidate, context),
+    immutableSpawn(candidate, context, state),
   );
   return {
     childProcessSpawns,
@@ -146,6 +146,7 @@ const collectSpawns = (
 const immutableSpawn = (
   candidate: SpawnCandidate,
   context: ChildSpawnContext,
+  state: JavaScriptSemanticAnalysisState,
 ): JavaScriptSemanticChildProcessSpawn => {
   const { options, argvCount } = spawnArguments(candidate, context);
   const command = dataEffectLiteralString(candidate.node.arguments[0]);
@@ -161,7 +162,7 @@ const immutableSpawn = (
     projectedResultBindings: candidate.projectedResultBindings,
     command,
     argvCount,
-    environmentSupplied: environmentSupplied(options, context),
+    environmentSupplied: environmentSupplied(options, context, state),
     stdioMode: stdioMode(options, candidate.method, context),
     resolution: command === null ? "partial" : "complete",
   };
@@ -443,11 +444,17 @@ const spawnArguments = (
 const environmentSupplied = (
   options: t.Node | undefined,
   context: ChildSpawnContext,
+  state: JavaScriptSemanticAnalysisState,
 ): boolean => {
   const lookup = staticObjectProperty(options, "env", context.isNullish);
   if (lookup.status !== "explicit") return false;
   const value = unwrapJavaScriptExpression(lookup.value).node;
   if (context.isNullish(value)) return false;
+  if (
+    t.isIdentifier(value, { name: "NaN" }) &&
+    isUnshadowedGlobal(value, state, "NaN")
+  )
+    return false;
   return staticJavaScriptTruthiness(value) !== false;
 };
 

src/domain/liveBinaryTargetSummary.ts

@@ -83,6 +83,7 @@ export const liveBinaryTargetSummaryVariants = [
       "uf2",
       "dfuse",
       "fit",
+      "ntfs-mft",
     ]),
     architecture: z.null(),
   }),

src/domain/native/nativeInspection.ts

@@ -2,7 +2,10 @@ import { z } from "zod";
 import { bundleResourceRootSchema } from "../apple/bundleResourceRoot.js";
 import { jsonRecordSchema } from "../jsonRecord.js";
 import { jsonValueSchema } from "../jsonValue.js";
-import { machoSliceEncryptionSchema } from "../apple/machoEncryption.js";
+import {
+  machoSliceEncryptionSchema,
+  retainedMachoSliceEncryptionSchema,
+} from "../apple/machoEncryption.js";
 
 const hexAddress = z.string().regex(/^0x[a-fA-F0-9]+$/u);
 const bytesHex = z.string().regex(/^(?:[0-9a-f]{2})*$/u);
@@ -223,7 +226,9 @@ export const inspectMachoSchema = z.object({
  * slice is encrypted.
  */
 export const retainedInspectMachoSchema = inspectMachoSchema
-  .extend({ encryption: inspectMachoSchema.shape.encryption.optional() })
+  .extend({
+    encryption: coverage(retainedMachoSliceEncryptionSchema).optional(),
+  })
   .transform(({ encryption, ...report }) => ({
     ...report,
     encryption: encryption ?? {

src/domain/windows/ntfsMft.test.ts

@@ -0,0 +1,478 @@
+import { describe, expect, it } from "vitest";
+
+import {
+  MFT_DEFAULT_RECORD_BYTES,
+  MFT_MAX_FILE_BYTES,
+  createMftDecoder,
+  parseMftImage,
+} from "./ntfsMft.js";
+
+interface RecordOptions {
+  readonly sequenceNumber?: number;
+  readonly hardLinkCount?: number;
+  readonly flags?: number;
+  readonly baseRecordReference?: bigint;
+  readonly recordBytes?: number;
+  /** Write a wrong trailer value into this sector, leaving the others correct. */
+  readonly corruptSector?: number;
+  /** Truncate the update sequence array to this many entries; 0 omits it. */
+  readonly usaEntries?: number;
+  readonly usaOffset?: number;
+}
+
+/** One FILE record with a zeroed body and fixups applied the way NTFS writes them. */
+const recordOf = (options: RecordOptions = {}): Uint8Array => {
+  const recordBytes = options.recordBytes ?? MFT_DEFAULT_RECORD_BYTES;
+  const record = new Uint8Array(recordBytes);
+  const view = new DataView(record.buffer);
+  record.set(Buffer.from("FILE", "latin1"), 0);
+  const sequenceNumber = options.sequenceNumber ?? 1;
+  const sectors = recordBytes / 512;
+
+  const usaEntries = options.usaEntries ?? sectors + 1;
+  if (usaEntries > 0) {
+    const usaOffset = options.usaOffset ?? 48;
+    view.setUint16(4, usaOffset, true);
+    view.setUint16(6, usaEntries, true);
+    view.setUint16(usaOffset, sequenceNumber, true);
+    for (let sector = 0; sector < sectors; sector += 1) {
+      const trailer = sector * 512 + 510;
+      // A saved trailer is what the sector held before the fixup replaced it.
+      view.setUint16(usaOffset + 2 * (sector + 1), 0xa5a5, true);
+      view.setUint16(
+        trailer,
+        sector >= usaEntries - 1
+          ? 0xa5a5
+          : sector === options.corruptSector
+            ? 0x1234
+            : sequenceNumber,
+        true,
+      );
+    }
+  } else {
+    view.setUint16(4, 0, true);
+    view.setUint16(6, 0, true);
+  }
+
+  view.setUint16(16, sequenceNumber, true);
+  view.setUint16(18, options.hardLinkCount ?? 1, true);
+  const firstAttributeOffset =
+    Math.ceil((48 + Math.max(0, usaEntries) * 2) / 8) * 8;
+  view.setUint16(20, firstAttributeOffset, true);
+  view.setUint16(22, options.flags ?? 0x0001, true);
+  view.setUint32(24, firstAttributeOffset + 8, true);
+  view.setUint32(firstAttributeOffset, 0xffff_ffff, true);
+  view.setUint32(28, recordBytes, true);
+  view.setBigUint64(32, options.baseRecordReference ?? 0n, true);
+  view.setUint16(40, 0, true);
+  return record;
+};
+
+const streamOf = (...records: readonly Uint8Array[]): Uint8Array => {
+  const total = records.reduce((sum, record) => sum + record.length, 0);
+  const stream = new Uint8Array(total);
+  let offset = 0;
+  for (const record of records) {
+    stream.set(record, offset);
+    const view = new DataView(stream.buffer, offset, record.length);
+    if (view.getUint16(4, true) >= 48)
+      view.setUint32(44, offset / record.length, true);
+    offset += record.length;
+  }
+  return stream;
+};
+
+describe("MFT header facts", () => {
+  it("inventories a clean record's header and verified fixups", () => {
+    const parsed = parseMftImage(streamOf(recordOf({ sequenceNumber: 5 })));
+    expect(parsed.ok).toBe(true);
+    if (!parsed.ok) return;
+    expect(parsed.value.metadata).toMatchObject({
+      kind: "ntfs-mft",
+      record_bytes: MFT_DEFAULT_RECORD_BYTES,
+      record_count: 1,
+      in_use_record_count: 1,
+      directory_record_count: 0,
+      extension_record_count: 0,
+      fixup_mismatch_count: 0,
+      fixup_unverified_record_count: 0,
+      truncated_tail_bytes: 0,
+    });
+    expect(parsed.value.records[0]).toMatchObject({
+      index: 0,
+      fileOffset: 0,
+      sequenceNumber: 5,
+      inUse: true,
+      directory: false,
+      baseRecordReference: null,
+      firstAttributeOffset: 56,
+      fixups: {
+        sequenceNumber: 5,
+        verifiedSectors: 2,
+        coveredSectors: 2,
+        mismatchSector: null,
+        malformed: false,
+      },
+    });
+    expect(parsed.value.limitations).toEqual([]);
+  });
+
+  it("identifies unrecognized flags without losing their source bits", () => {
+    const parsed = parseMftImage(recordOf({ flags: 0x8001 }));
+    if (!parsed.ok) throw new Error(parsed.error.message);
+    expect(parsed.value.metadata.record_headers[0]?.flags).toEqual({
+      raw: 0x8001,
+      names: ["in-use"],
+      unknownMask: 0x8000,
+    });
+  });
+
+  it.each([0, 49, 64, 72])(
+    "reports an invalid first attribute offset %i",
+    (offset) => {
+      const record = recordOf();
+      new DataView(record.buffer).setUint16(20, offset, true);
+      const parsed = parseMftImage(record);
+      if (!parsed.ok) throw new Error(parsed.error.message);
+      expect(parsed.value.records[0]?.extentValid).toBe(false);
+      expect(parsed.value.limitations.join(" ")).toContain("inconsistent");
+    },
+  );
+
+  it("reports a declared record number that contradicts its stream position", () => {
+    const bytes = streamOf(recordOf(), recordOf());
+    new DataView(bytes.buffer).setUint32(1024 + 44, 0, true);
+    const parsed = parseMftImage(bytes);
+    if (!parsed.ok) throw new Error(parsed.error.message);
+    expect(parsed.value.records[1]).toMatchObject({
+      index: 1,
+      declaredRecordNumber: 0,
+      recordNumberMatchesSlot: false,
+    });
+    expect(parsed.value.limitations.join(" ")).toContain(
+      "disagrees with their stream slot",
+    );
+  });
+
+  it("keeps the inline header window separate from the parsed record count", () => {
+    const parsed = parseMftImage(
+      streamOf(...Array.from({ length: 33 }, () => recordOf())),
+    );
+    if (!parsed.ok) throw new Error(parsed.error.message);
+    expect(parsed.value.metadata).toMatchObject({
+      record_count: 33,
+      omitted_record_headers: 1,
+    });
+    expect(parsed.value.metadata.record_headers).toHaveLength(32);
+    expect(parsed.value.records).toHaveLength(33);
+    expect(parsed.value.limitations).toEqual([]);
+  });
+
+  it("preserves a log sequence number above the safe integer range", () => {
+    const record = recordOf();
+    new DataView(record.buffer).setBigUint64(8, 9007199254740993n, true);
+    const parsed = parseMftImage(record);
+    if (!parsed.ok) throw new Error(parsed.error.message);
+    expect(parsed.value.records[0]?.logFileSequenceNumber).toBe(
+      "9007199254740993",
+    );
+  });
+
+  it("verifies the older FILE header without reading its fixup words as a record number", () => {
+    const oldRecord = recordOf({ usaOffset: 42 });
+    const newRecord = recordOf();
+    new DataView(newRecord.buffer).setUint32(44, 1, true);
+
+    const parsed = parseMftImage(streamOf(oldRecord, newRecord));
+    if (!parsed.ok) throw new Error(parsed.error.message);
+    expect(parsed.value.records).toMatchObject([
+      {
+        declaredRecordNumber: null,
+        fixups: { malformed: false, verifiedSectors: 2 },
+      },
+      {
+        declaredRecordNumber: 1,
+        fixups: { malformed: false, verifiedSectors: 2 },
+      },
+    ]);
+    expect(parsed.value.limitations).toEqual([]);
+  });
+});
+
+describe("MFT fixup coverage", () => {
+  it.each([0, 0xffff])(
+    "leaves reserved USA sequence %i unverified",
+    (sequenceNumber) => {
+      const parsed = parseMftImage(recordOf({ sequenceNumber }));
+      if (!parsed.ok) throw new Error(parsed.error.message);
+      expect(parsed.value.records[0]?.fixups).toMatchObject({
+        sequenceNumber,
+        verifiedSectors: 0,
+        malformed: true,
+      });
+      expect(parsed.value.metadata.fixup_unverified_record_count).toBe(1);
+      expect(parsed.value.limitations.join(" ")).toContain(
+        "invalid or incomplete",
+      );
+    },
+  );
+
+  it("keeps a record whose sector trailer is not the sequence number, and reports it", () => {
+    const parsed = parseMftImage(
+      streamOf(recordOf(), recordOf({ sequenceNumber: 9, corruptSector: 1 })),
+    );
+    expect(parsed.ok).toBe(true);
+    if (!parsed.ok) return;
+    expect(parsed.value.records[1]?.fixups).toMatchObject({
+      sequenceNumber: 9,
+      verifiedSectors: 1,
+      mismatchSector: 1,
+    });
+    expect(parsed.value.metadata.fixup_mismatch_count).toBe(1);
+    expect(parsed.value.limitations.join(" ")).toMatch(
+      /1 record\(s\) hold a sector trailer/u,
+    );
+  });
+
+  it("treats a missing update sequence array as unverified rather than clean", () => {
+    const parsed = parseMftImage(streamOf(recordOf({ usaEntries: 0 })));
+    expect(parsed.ok).toBe(true);
+    if (!parsed.ok) return;
+    expect(parsed.value.records[0]?.fixups).toMatchObject({
+      malformed: true,
+      mismatchSector: null,
+      coveredSectors: 0,
+    });
+    expect(parsed.value.metadata.fixup_mismatch_count).toBe(0);
+    expect(parsed.value.metadata.fixup_unverified_record_count).toBe(1);
+    expect(parsed.value.limitations.join(" ")).toMatch(
+      /invalid or incomplete update sequence array/u,
+    );
+  });
+
+  it.each([
+    [48, 4],
+    [49, 3],
+    [508, 3],
+  ])(
+    "rejects a malformed update sequence array at %i with %i entries",
+    (offset, count) => {
+      const bytes = recordOf();
+      const view = new DataView(bytes.buffer);
+      view.setUint16(4, offset, true);
+      view.setUint16(6, count, true);
+
+      const parsed = parseMftImage(bytes);
+      if (!parsed.ok) throw new Error(parsed.error.message);
+      expect(parsed.value.records[0]?.fixups).toMatchObject({
+        malformed: true,
+        verifiedSectors: 0,
+      });
+      expect(parsed.value.metadata.fixup_unverified_record_count).toBe(1);
+    },
+  );
+
+  it("counts uncovered sectors independently of a mismatched trailer", () => {
+    const parsed = parseMftImage(
+      recordOf({ recordBytes: 4096, usaEntries: 3, corruptSector: 0 }),
+    );
+    if (!parsed.ok) throw new Error(parsed.error.message);
+    expect(parsed.value.metadata).toMatchObject({
+      fixup_mismatch_count: 1,
+      fixup_unverified_record_count: 1,
+    });
+    expect(parsed.value.limitations.join(" ")).toContain(
+      "invalid or incomplete",
+    );
+  });
+
+  it("reports an array that covers fewer sectors than the record has", () => {
+    // A 4 KiB record holds eight sectors; a three-entry array leaves five unverified.
+    const parsed = parseMftImage(
+      streamOf(recordOf({ recordBytes: 4096, usaEntries: 3 })),
+    );
+    expect(parsed.ok).toBe(true);
+    if (!parsed.ok) return;
+    expect(parsed.value.records[0]?.fixups).toMatchObject({
+      coveredSectors: 2,
+      verifiedSectors: 2,
+      mismatchSector: null,
+      malformed: false,
+    });
+    expect(parsed.value.metadata.fixup_unverified_record_count).toBe(1);
+  });
+});
+
+describe("MFT record slots", () => {
+  it("distinguishes extension records from base records", () => {
+    const parsed = parseMftImage(
+      streamOf(
+        recordOf(),
+        recordOf({
+          flags: 0x0005,
+          baseRecordReference: 0xabcd_fedc_ba98_7654n,
+        }),
+      ),
+    );
+    expect(parsed.ok).toBe(true);
+    if (!parsed.ok) return;
+    expect(parsed.value.records[1]).toMatchObject({
+      baseRecordReference: {
+        recordNumber: 0xfedc_ba98_7654,
+        sequenceNumber: 0xabcd,
+      },
+      flags: { raw: 0x0005, names: ["in-use", "system"] },
+    });
+    expect(parsed.value.metadata.extension_record_count).toBe(1);
+  });
+
+  it("names directory records without losing the in-use flag", () => {
+    const parsed = parseMftImage(streamOf(recordOf({ flags: 0x0003 })));
+    expect(parsed.ok).toBe(true);
+    if (!parsed.ok) return;
+    expect(parsed.value.records[0]).toMatchObject({
+      directory: true,
+      inUse: true,
+      flags: { names: ["in-use", "directory"] },
+    });
+    expect(parsed.value.metadata.directory_record_count).toBe(1);
+  });
+
+  it("skips malformed and sparse slots without renumbering valid records", () => {
+    const stream = streamOf(
+      recordOf(),
+      recordOf(),
+      new Uint8Array(MFT_DEFAULT_RECORD_BYTES),
+      recordOf(),
+    );
+    stream.set(Buffer.from("BAAD", "latin1"), MFT_DEFAULT_RECORD_BYTES);
+    const parsed = parseMftImage(stream);
+    expect(parsed.ok).toBe(true);
+    if (!parsed.ok) return;
+    expect(parsed.value.metadata.record_count).toBe(2);
+    expect(
+      parsed.value.records.map(({ index, fileOffset }) => [index, fileOffset]),
+    ).toEqual([
+      [0, 0],
+      [3, 3 * MFT_DEFAULT_RECORD_BYTES],
+    ]);
+    expect(parsed.value.limitations).toEqual([
+      "record at 1024 does not begin with the FILE signature; 2 slot(s) without a FILE signature were found",
+    ]);
+  });
+
+  it("keeps a trailing partial record out of the inventory", () => {
+    const stream = new Uint8Array(1024 + 300);
+    stream.set(recordOf(), 0);
+    const parsed = parseMftImage(stream);
+    expect(parsed.ok).toBe(true);
+    if (!parsed.ok) return;
+    expect(parsed.value.metadata.record_count).toBe(1);
+    expect(parsed.value.metadata.truncated_tail_bytes).toBe(300);
+    expect(parsed.value.limitations.join(" ")).toMatch(
+      /300 trailing byte\(s\)/u,
+    );
+  });
+
+  it("falls back to the default record size when record 0 declares none", () => {
+    const record = recordOf();
+    new DataView(record.buffer).setUint32(28, 0, true);
+    const parsed = parseMftImage(record);
+    expect(parsed.ok).toBe(true);
+    if (!parsed.ok) return;
+    expect(parsed.value.recordBytes).toBe(MFT_DEFAULT_RECORD_BYTES);
+    expect(parsed.value.limitations.join(" ")).toMatch(
+      /not a supported power of two/u,
+    );
+  });
+
+  it("reads a 4 KiB record at its declared size", () => {
+    const parsed = parseMftImage(streamOf(recordOf({ recordBytes: 4096 })));
+    expect(parsed.ok).toBe(true);
+    if (!parsed.ok) return;
+    expect(parsed.value.recordBytes).toBe(4096);
+    expect(parsed.value.metadata.record_count).toBe(1);
+  });
+});
+
+describe("parseMftImage refusals and limits", () => {
+  it("refuses a file shorter than one record header", () => {
+    const parsed = parseMftImage(new Uint8Array(32));
+    expect(parsed.ok).toBe(false);
+    if (parsed.ok) return;
+    expect(parsed.error.message).toMatch(
+      /shorter than one 42-byte record header/u,
+    );
+  });
+
+  it("refuses bytes that do not start with the FILE signature", () => {
+    const parsed = parseMftImage(Buffer.alloc(2048, 0x41));
+    expect(parsed.ok).toBe(false);
+    if (parsed.ok) return;
+    expect(parsed.error.message).toMatch(
+      /does not begin with the FILE signature/u,
+    );
+  });
+
+  it("refuses a file above the fixed ceiling", () => {
+    const decoder = createMftDecoder(MFT_MAX_FILE_BYTES + 1);
+    expect(decoder.ok).toBe(false);
+    if (decoder.ok) return;
+    expect(decoder.error).toMatchObject({
+      kind: "limit",
+      boundary: "file-size",
+    });
+  });
+
+  it("refuses streams that differ from the admitted byte count", () => {
+    const stream = recordOf();
+    const short = createMftDecoder(stream.length + 1);
+    if (!short.ok) throw new Error(short.error.message);
+    expect(short.value.write(stream).ok).toBe(true);
+    expect(short.value.finish()).toMatchObject({
+      ok: false,
+      error: {
+        kind: "format",
+        message: "stream ended before the admitted file length",
+      },
+    });
+
+    const long = createMftDecoder(stream.length - 1);
+    if (!long.ok) throw new Error(long.error.message);
+    expect(long.value.write(stream)).toMatchObject({
+      ok: false,
+      error: {
+        kind: "format",
+        message: "received more bytes than the admitted file length",
+      },
+    });
+  });
+
+  it("returns the same inventory without retaining all the decoded records", () => {
+    const bytes = streamOf(...Array.from({ length: 33 }, () => recordOf()));
+    const decoder = createMftDecoder(bytes.length);
+    const parsed = parseMftImage(bytes);
+    if (!decoder.ok || !parsed.ok) throw new Error("invalid fixture");
+    expect(decoder.value.write(bytes).ok).toBe(true);
+    const inventory = decoder.value.finish();
+    if (!inventory.ok) throw new Error(inventory.error.message);
+    expect(inventory.value).not.toHaveProperty("records");
+    expect(inventory.value.metadata).toEqual(parsed.value.metadata);
+    expect(inventory.value.limitations).toEqual(parsed.value.limitations);
+  });
+
+  it("decodes the same stream through the chunked decoder", () => {
+    const stream = streamOf(recordOf(), recordOf({ flags: 0x0003 }));
+    const decoder = createMftDecoder(stream.length);
+    expect(decoder.ok).toBe(true);
+    if (!decoder.ok) return;
+    // Feed one byte past a record boundary so a chunk never aligns with a record.
+    for (const chunk of [stream.subarray(0, 1025), stream.subarray(1025)])
+      expect(decoder.value.write(chunk).ok).toBe(true);
+    const image = decoder.value.finish();
+    expect(image.ok).toBe(true);
+    if (!image.ok) return;
+    expect(image.value.metadata.record_count).toBe(2);
+    expect(image.value.metadata.directory_record_count).toBe(1);
+  });
+});

src/domain/windows/ntfsMft.ts

@@ -0,0 +1,512 @@
+import { err, ok, type Result } from "../result.js";
+import type {
+  RegionDecodeFailure,
+  RegionDecoder,
+} from "../firmware/regionDecoder.js";
+
+/** An NTFS FILE record begins with this signature. */
+const MFT_FILE_RECORD_MAGIC = "FILE";
+const MFT_FILE_RECORD_MAGIC_BYTES = 4;
+/** The shortest header worth reading: a FILE record header ends at `nextAttributeId`. */
+const NTFS_MFT_MIN_RECORD_BYTES = 42;
+
+const hasMftFileRecordSignature = (prefix: Uint8Array): boolean =>
+  prefix.length >= MFT_FILE_RECORD_MAGIC_BYTES &&
+  text(prefix.subarray(0, MFT_FILE_RECORD_MAGIC_BYTES)) ===
+    MFT_FILE_RECORD_MAGIC;
+
+/** A record's declared size is a power of two from 512 upward; 1024 is NTFS's default. */
+export const MFT_DEFAULT_RECORD_BYTES = 1024;
+const MFT_MIN_RECORD_BYTES = 512;
+const MFT_MAX_RECORD_BYTES = 65536;
+/** An update sequence array holds at least the sequence number and one fixup word. */
+const USA_MIN_ENTRIES = 2;
+/** NTFS fixes up one 512-byte sector at a time. */
+const FIXUP_SECTOR_BYTES = 512;
+/**
+ * Fixed whole-file ceiling. Records are inventoried from their headers only;
+ * attributes and their payloads are not decoded, so this is deliberately
+ * smaller than a volume's MFT can be.
+ */
+export const MFT_MAX_FILE_BYTES = 512 * 1024 * 1024;
+/** Limit the inline header sample independently of full stream coverage. */
+export const MFT_INLINE_HEADER_LIMIT = 32;
+
+/** FILE record header fields; offsets are from the record start. */
+const RECORD_HEADER = {
+  updateSequenceOffset: 4,
+  updateSequenceCount: 6,
+  logFileSequenceNumber: 8,
+  sequenceNumber: 16,
+  hardLinkCount: 18,
+  firstAttributeOffset: 20,
+  flags: 22,
+  usedBytes: 24,
+  totalBytes: 28,
+  baseRecordReference: 32,
+  nextAttributeId: 40,
+  recordNumber: 44,
+} as const;
+const RECORD_HEADER_WITH_NUMBER_BYTES = 48;
+
+const FILE_RECORD_IN_USE = 0x0001;
+const FILE_RECORD_IS_DIRECTORY = 0x0002;
+const FILE_RECORD_NAMES = new Map<number, string>([
+  [FILE_RECORD_IN_USE, "in-use"],
+  [FILE_RECORD_IS_DIRECTORY, "directory"],
+  [0x0004, "system"],
+  [0x0008, "view-index"],
+]);
+
+export interface MftRecordFixups {
+  /** The update sequence number the array's first entry holds, or 0 when absent. */
+  readonly sequenceNumber: number;
+  readonly entries: number;
+  /** Sectors whose trailer held the sequence number before a mismatch. */
+  readonly verifiedSectors: number;
+  /** Sectors the array covers; fewer than the record's sectors leaves a tail unverified. */
+  readonly coveredSectors: number;
+  /** The first sector whose trailer did not hold the sequence number, if any. */
+  readonly mismatchSector: number | null;
+  /** The array itself is missing, misplaced or too short to cover one sector. */
+  readonly malformed: boolean;
+}
+
+export interface MftFileReference {
+  readonly recordNumber: number;
+  readonly sequenceNumber: number;
+}
+
+const decodeMftFileReference = (reference: bigint): MftFileReference => ({
+  recordNumber: Number(reference & 0xffff_ffff_ffffn),
+  sequenceNumber: Number(reference >> 48n),
+});
+
+export interface MftRecord {
+  /** Zero-based ordinal of this record in the stream. */
+  readonly index: number;
+  /** File offset where the record starts. */
+  readonly fileOffset: number;
+  readonly sequenceNumber: number;
+  /** Hard link count as recorded; a zero count marks a record with no names. */
+  readonly hardLinkCount: number;
+  readonly flags: {
+    readonly raw: number;
+    readonly names: readonly string[];
+    readonly unknownMask: number;
+  };
+  readonly inUse: boolean;
+  readonly directory: boolean;
+  /** Used and allocated byte counts as declared by the FILE record. */
+  readonly usedBytes: number;
+  readonly totalBytes: number;
+  readonly extentValid: boolean;
+  /** The base record this is an extension of, or `null` for a base record. */
+  readonly baseRecordReference: MftFileReference | null;
+  /** The record number the header declares; `null` when the header predates the field. */
+  readonly declaredRecordNumber: number | null;
+  readonly recordNumberMatchesSlot: boolean | null;
+  /** `$LogFile` sequence number as recorded; no log is read. */
+  readonly logFileSequenceNumber: string;
+  /** Declared offset of the first attribute; no attribute decoding follows yet. */
+  readonly firstAttributeOffset: number;
+  /** Declared id of the next attribute; no attribute decoding follows yet. */
+  readonly nextAttributeId: number;
+  readonly fixups: MftRecordFixups;
+}
+
+export interface MftInventory {
+  readonly metadata: MftMetadata;
+  /** The record size the stream declared, or the fixed default when it did not. */
+  readonly recordBytes: number;
+  readonly limitations: readonly string[];
+}
+
+export interface MftImage extends MftInventory {
+  readonly records: readonly MftRecord[];
+}
+
+export interface MftMetadata {
+  readonly kind: "ntfs-mft";
+  readonly record_bytes: number;
+  readonly record_count: number;
+  readonly in_use_record_count: number;
+  readonly directory_record_count: number;
+  readonly extension_record_count: number;
+  readonly fixup_mismatch_count: number;
+  readonly fixup_unverified_record_count: number;
+  readonly truncated_tail_bytes: number;
+  readonly record_headers: readonly MftRecord[];
+  readonly omitted_record_headers: number;
+}
+
+const text = (ascii: Uint8Array): string =>
+  Buffer.from(ascii).toString("latin1");
+
+const failure = (
+  message: string,
+  boundary?: RegionDecodeFailure["boundary"],
+): RegionDecodeFailure => ({
+  kind: "format",
+  message,
+  ...(boundary === undefined ? {} : { boundary }),
+});
+
+const limit = (
+  message: string,
+  boundary?: RegionDecodeFailure["boundary"],
+): RegionDecodeFailure => ({
+  kind: "limit",
+  message,
+  ...(boundary === undefined ? {} : { boundary }),
+});
+
+const parseRecordFlags = (raw: number): MftRecord["flags"] => {
+  const names: string[] = [];
+  let unknownMask = raw;
+  for (const [bit, name] of FILE_RECORD_NAMES) {
+    if ((raw & bit) !== 0) names.push(name);
+    unknownMask &= ~bit;
+  }
+  return { raw, names, unknownMask };
+};
+
+const isRecordSize = (bytes: number): boolean =>
+  bytes >= MFT_MIN_RECORD_BYTES &&
+  bytes <= MFT_MAX_RECORD_BYTES &&
+  (bytes & (bytes - 1)) === 0;
+
+const updateSequenceArrayFits = (
+  offset: number,
+  entries: number,
+  sectors: number,
+): boolean =>
+  entries >= USA_MIN_ENTRIES &&
+  entries <= sectors + 1 &&
+  offset >= NTFS_MFT_MIN_RECORD_BYTES &&
+  offset % 2 === 0 &&
+  offset + entries * 2 <= FIXUP_SECTOR_BYTES - 2;
+
+/** Recognize a FILE header without requiring its trailers or attributes to verify. */
+export const hasMftFileRecordHeader = (prefix: Uint8Array): boolean => {
+  if (
+    prefix.length < NTFS_MFT_MIN_RECORD_BYTES ||
+    !hasMftFileRecordSignature(prefix)
+  )
+    return false;
+  const view = new DataView(
+    prefix.buffer,
+    prefix.byteOffset,
+    prefix.byteLength,
+  );
+  return (
+    isRecordSize(view.getUint32(RECORD_HEADER.totalBytes, true)) ||
+    updateSequenceArrayFits(
+      view.getUint16(RECORD_HEADER.updateSequenceOffset, true),
+      view.getUint16(RECORD_HEADER.updateSequenceCount, true),
+      MFT_DEFAULT_RECORD_BYTES / FIXUP_SECTOR_BYTES,
+    )
+  );
+};
+
+/**
+ * Parse FILE record headers and verify their update-sequence fixups.
+ *
+ * Only the record structure is established: attributes, their names, the
+ * filenames and the USN journal are left to later steps, so no path, timestamp
+ * or file identity beyond the record itself is claimed. A record whose fixup
+ * does not match keeps its header facts, because the stream still declares it,
+ * and the mismatch is reported on the record and counted in the metadata.
+ */
+export const parseMftImage = (
+  bytes: Uint8Array,
+): Result<MftImage, RegionDecodeFailure> => {
+  const records: MftRecord[] = [];
+  const inventory = scanMft(bytes, records);
+  return inventory.ok ? ok({ ...inventory.value, records }) : inventory;
+};
+
+const scanMft = (
+  bytes: Uint8Array,
+  retainedRecords?: MftRecord[],
+): Result<MftInventory, RegionDecodeFailure> => {
+  if (bytes.length < NTFS_MFT_MIN_RECORD_BYTES)
+    return err(
+      failure(
+        `file is ${String(bytes.length)} bytes, shorter than one ${String(NTFS_MFT_MIN_RECORD_BYTES)}-byte record header`,
+      ),
+    );
+  if (!hasMftFileRecordSignature(bytes))
+    return err(failure("record 0 does not begin with the FILE signature"));
+
+  const limitations: string[] = [];
+  const header = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const declaredRecordBytes = header.getUint32(RECORD_HEADER.totalBytes, true);
+  const recordBytes = isRecordSize(declaredRecordBytes)
+    ? declaredRecordBytes
+    : MFT_DEFAULT_RECORD_BYTES;
+  if (!isRecordSize(declaredRecordBytes))
+    limitations.push(
+      `record 0 declares a record size of ${String(declaredRecordBytes)} bytes, which is not a supported power of two from ${String(MFT_MIN_RECORD_BYTES)} to ${String(MFT_MAX_RECORD_BYTES)}; records were read at the ${String(MFT_DEFAULT_RECORD_BYTES)}-byte default`,
+    );
+
+  const recordHeaders: MftRecord[] = [];
+  let recordCount = 0;
+  let inUseCount = 0;
+  let directoryCount = 0;
+  let extensionCount = 0;
+  let mismatchCount = 0;
+  let unverifiedCount = 0;
+  let invalidSlots = 0;
+  let invalidExtents = 0;
+  let inconsistentRecordNumbers = 0;
+  let firstInvalidExtentOffset: number | undefined;
+  let firstInvalidOffset: number | undefined;
+  for (
+    let offset = 0;
+    offset + recordBytes <= bytes.length;
+    offset += recordBytes
+  ) {
+    if (
+      !hasMftFileRecordSignature(
+        bytes.subarray(offset, offset + MFT_FILE_RECORD_MAGIC_BYTES),
+      )
+    ) {
+      invalidSlots += 1;
+      firstInvalidOffset ??= offset;
+      if (!isRecordSize(declaredRecordBytes)) break;
+      continue;
+    }
+    const record = readRecord(bytes, offset, offset / recordBytes, recordBytes);
+    retainedRecords?.push(record);
+    if (recordHeaders.length < MFT_INLINE_HEADER_LIMIT)
+      recordHeaders.push(record);
+    recordCount += 1;
+    if (record.inUse) inUseCount += 1;
+    if (record.directory) directoryCount += 1;
+    if (record.baseRecordReference !== null) extensionCount += 1;
+    if (record.fixups.mismatchSector !== null) mismatchCount += 1;
+    if (
+      record.fixups.malformed ||
+      record.fixups.coveredSectors < recordBytes / FIXUP_SECTOR_BYTES
+    )
+      unverifiedCount += 1;
+    if (record.recordNumberMatchesSlot === false)
+      inconsistentRecordNumbers += 1;
+    if (!record.extentValid) {
+      invalidExtents += 1;
+      firstInvalidExtentOffset ??= offset;
+    }
+  }
+  if (firstInvalidOffset !== undefined)
+    limitations.push(
+      `record at ${String(firstInvalidOffset)} does not begin with the FILE signature; ${String(invalidSlots)} slot(s) without a FILE signature were found`,
+    );
+
+  if (firstInvalidExtentOffset !== undefined)
+    limitations.push(
+      `${String(invalidExtents)} FILE record(s) declare inconsistent record extents, beginning at offset ${String(firstInvalidExtentOffset)}`,
+    );
+
+  if (inconsistentRecordNumbers !== 0)
+    limitations.push(
+      `${String(inconsistentRecordNumbers)} FILE record(s) declare a record number that disagrees with their stream slot`,
+    );
+
+  const truncatedTailBytes = bytes.length % recordBytes;
+  if (truncatedTailBytes !== 0)
+    limitations.push(
+      `${String(truncatedTailBytes)} trailing byte(s) do not fill a ${String(recordBytes)}-byte record and were not parsed`,
+    );
+
+  if (mismatchCount !== 0)
+    limitations.push(
+      `${String(mismatchCount)} record(s) hold a sector trailer that is not the update sequence number; their attributes were not read and no later step should trust them`,
+    );
+  if (unverifiedCount !== 0)
+    limitations.push(
+      `${String(unverifiedCount)} record(s) carry an invalid or incomplete update sequence array; their sector trailers were not fully verified`,
+    );
+
+  const metadata: MftMetadata = {
+    kind: "ntfs-mft",
+    record_bytes: recordBytes,
+    record_count: recordCount,
+    in_use_record_count: inUseCount,
+    directory_record_count: directoryCount,
+    extension_record_count: extensionCount,
+    fixup_mismatch_count: mismatchCount,
+    fixup_unverified_record_count: unverifiedCount,
+    truncated_tail_bytes: truncatedTailBytes,
+    record_headers: recordHeaders,
+    omitted_record_headers: recordCount - recordHeaders.length,
+  };
+
+  return ok({ metadata, recordBytes, limitations });
+};
+
+const readRecord = (
+  bytes: Uint8Array,
+  fileOffset: number,
+  index: number,
+  recordBytes: number,
+): MftRecord => {
+  const record = bytes.subarray(fileOffset, fileOffset + recordBytes);
+  const view = new DataView(
+    record.buffer,
+    record.byteOffset,
+    record.byteLength,
+  );
+
+  const flags = view.getUint16(RECORD_HEADER.flags, true);
+  const baseRecordReference = view.getBigUint64(
+    RECORD_HEADER.baseRecordReference,
+    true,
+  );
+
+  const usaOffset = view.getUint16(RECORD_HEADER.updateSequenceOffset, true);
+  const fixups = verifyFixups(record, view, usaOffset);
+  const usedBytes = view.getUint32(RECORD_HEADER.usedBytes, true);
+  const totalBytes = view.getUint32(RECORD_HEADER.totalBytes, true);
+  const firstAttributeOffset = view.getUint16(
+    RECORD_HEADER.firstAttributeOffset,
+    true,
+  );
+
+  const declaredRecordNumber =
+    !fixups.malformed && usaOffset >= RECORD_HEADER_WITH_NUMBER_BYTES
+      ? view.getUint32(RECORD_HEADER.recordNumber, true)
+      : null;
+
+  return {
+    index,
+    fileOffset,
+    sequenceNumber: view.getUint16(RECORD_HEADER.sequenceNumber, true),
+    hardLinkCount: view.getUint16(RECORD_HEADER.hardLinkCount, true),
+    flags: parseRecordFlags(flags),
+    inUse: (flags & FILE_RECORD_IN_USE) !== 0,
+    directory: (flags & FILE_RECORD_IS_DIRECTORY) !== 0,
+    usedBytes,
+    totalBytes,
+    extentValid:
+      totalBytes === recordBytes &&
+      usedBytes >= NTFS_MFT_MIN_RECORD_BYTES &&
+      usedBytes % 8 === 0 &&
+      usedBytes <= totalBytes &&
+      firstAttributeOffset % 8 === 0 &&
+      firstAttributeOffset >= NTFS_MFT_MIN_RECORD_BYTES &&
+      firstAttributeOffset + 4 <= usedBytes &&
+      (fixups.malformed ||
+        firstAttributeOffset >= usaOffset + fixups.entries * 2),
+    baseRecordReference:
+      baseRecordReference === 0n
+        ? null
+        : decodeMftFileReference(baseRecordReference),
+    declaredRecordNumber,
+    recordNumberMatchesSlot:
+      declaredRecordNumber === null ? null : declaredRecordNumber === index,
+    logFileSequenceNumber: view
+      .getBigUint64(RECORD_HEADER.logFileSequenceNumber, true)
+      .toString(),
+    firstAttributeOffset,
+    nextAttributeId: view.getUint16(RECORD_HEADER.nextAttributeId, true),
+    fixups,
+  };
+};
+
+/**
+ * Each sector's last two bytes are replaced on disk by the update sequence
+ * number; the array's first entry is that number and the rest are the saved
+ * trailer words. A sector whose trailer is not the sequence number was not
+ * cleanly written, so the record's attributes cannot be trusted.
+ */
+const verifyFixups = (
+  record: Uint8Array,
+  view: DataView,
+  usaOffset: number,
+): MftRecordFixups => {
+  const usaCount = view.getUint16(RECORD_HEADER.updateSequenceCount, true);
+  const sectors = Math.floor(record.length / FIXUP_SECTOR_BYTES);
+  // Entry 0 holds the sequence number, so sector n's saved trailer is entry n+1.
+  const coveredSectors = Math.max(0, usaCount - 1);
+
+  if (!updateSequenceArrayFits(usaOffset, usaCount, sectors))
+    return {
+      sequenceNumber: 0,
+      entries: usaCount,
+      verifiedSectors: 0,
+      coveredSectors: 0,
+      mismatchSector: null,
+      malformed: true,
+    };
+
+  const sequenceNumber = view.getUint16(usaOffset, true);
+  if (sequenceNumber === 0 || sequenceNumber === 0xffff)
+    return {
+      sequenceNumber,
+      entries: usaCount,
+      verifiedSectors: 0,
+      coveredSectors,
+      mismatchSector: null,
+      malformed: true,
+    };
+  for (let sector = 0; sector < coveredSectors; sector += 1) {
+    const trailerOffset = sector * FIXUP_SECTOR_BYTES + FIXUP_SECTOR_BYTES - 2;
+    if (view.getUint16(trailerOffset, true) !== sequenceNumber)
+      return {
+        sequenceNumber,
+        entries: usaCount,
+        verifiedSectors: sector,
+        coveredSectors,
+        mismatchSector: sector,
+        malformed: false,
+      };
+  }
+
+  return {
+    sequenceNumber,
+    entries: usaCount,
+    verifiedSectors: coveredSectors,
+    coveredSectors,
+    mismatchSector: null,
+    malformed: false,
+  };
+};
+
+/** Buffer the admitted input once while accepting arbitrary chunk boundaries. */
+class StreamingMftDecoder implements RegionDecoder<MftInventory> {
+  readonly #bytes: Uint8Array;
+  #written = 0;
+
+  constructor(fileBytes: number) {
+    this.#bytes = new Uint8Array(fileBytes);
+  }
+
+  write(chunk: Uint8Array): Result<void, RegionDecodeFailure> {
+    if (chunk.length > this.#bytes.length - this.#written)
+      return err(failure("received more bytes than the admitted file length"));
+    this.#bytes.set(chunk, this.#written);
+    this.#written += chunk.length;
+    return ok(undefined);
+  }
+
+  finish(): Result<MftInventory, RegionDecodeFailure> {
+    if (this.#written !== this.#bytes.length)
+      return err(failure("stream ended before the admitted file length"));
+    return scanMft(this.#bytes);
+  }
+}
+
+export const createMftDecoder = (
+  fileBytes: number,
+): Result<RegionDecoder<MftInventory>, RegionDecodeFailure> =>
+  Number.isSafeInteger(fileBytes) &&
+  fileBytes >= 0 &&
+  fileBytes <= MFT_MAX_FILE_BYTES
+    ? ok(new StreamingMftDecoder(fileBytes))
+    : err(
+        limit(
+          `file is ${String(fileBytes)} bytes, exceeding the fixed ${String(MFT_MAX_FILE_BYTES)}-byte (512 MiB) ceiling`,
+          "file-size",
+        ),
+      );

src/ghidra/GhidraFunctionValues.test.ts

@@ -1,4 +1,3 @@
-import { readFile } from "node:fs/promises";
 import { describe, expect, it } from "vitest";
 
 import type { JsonValue } from "../domain/jsonValue.js";
@@ -1120,25 +1119,6 @@ describe("Ghidra native instruction decoder context for ARM TMode and MIPS ISA_M
   });
 });
 
-describe("Ghidra bridge script processor context contract", () => {
-  it("binds TMode to ARM and ISA_MODE to MIPS in ReaGhidraBridge.java", async () => {
-    const bridgePath = new URL(
-      "../../bridge/ghidra/ReaGhidraBridge.java",
-      import.meta.url,
-    );
-    const content = await readFile(bridgePath, "utf8");
-    expect(content).toContain(
-      'currentProgram.getLanguageID().getIdAsString().startsWith("ARM:")',
-    );
-    expect(content).toContain(
-      'currentProgram.getLanguageID().getIdAsString().startsWith("MIPS:")',
-    );
-    expect(content).toContain('"TMode"');
-    expect(content).toContain('"ISA_MODE"');
-    expect(content).toContain('"ghidra-program-context"');
-  });
-});
-
 describe("Ghidra dossier nested boundary composition", () => {
   const identityLocations = [
     "caller",

src/native/AppleDispatchMetadata.test.ts

@@ -307,6 +307,7 @@ const swiftExternalSwiftBindingImage = (
     ...Buffer.from(
       `${boundField === "protocol" ? "_$sSQMp" : boundField === "objc-class" ? "_OBJC_CLASS_$_NSObject" : "_$sSiMn"}\0`,
     ),
+    0x51, // SET_TYPE_IMM pointer
     0x70,
     0x80,
     0x16, // SET_SEGMENT_AND_OFFSET_ULEB segment 0 + offset 0xb00
@@ -373,6 +374,7 @@ const swiftBoundWitnessSlotImage = () => {
     0x11,
     0x40,
     ...Buffer.from("_externalWitnessImpl\0"),
+    0x51, // SET_TYPE_IMM pointer
     0x70,
     0x88,
     0x1c, // SET_SEGMENT_AND_OFFSET_ULEB segment 0 + witness slot 0xe08
@@ -1107,6 +1109,7 @@ describe("Apple dispatch pointer fixup metadata", () => {
       const bindings = Buffer.from([
         0x40,
         ...Buffer.from("_OBJC_CLASS_$_NSObject\0"),
+        0x51, // SET_TYPE_IMM pointer
         0x70,
         0x88,
         0x04,
@@ -1456,6 +1459,7 @@ describe("Objective-C category class references without a class name", () => {
     const bindings = Buffer.from([
       0x40,
       ...Buffer.from("_$s4Main3FooCN\0"),
+      0x51, // SET_TYPE_IMM pointer
       0x70,
       0xc8,
       0x16,
@@ -1653,6 +1657,42 @@ describe("Objective-C category-local record-budget coverage", () => {
 });
 
 describe("malformed Objective-C property records", () => {
+  it.each(["class", "category"] as const)(
+    "retains the %s identity when its property-list pointer field is unmapped",
+    (owner) => {
+      const bytes = fixture(false, "partial-method");
+      if (owner === "class") {
+        bytes.writeBigUInt64LE(base + 0xfc0n, 0x220);
+        bytes.writeUInt32LE(2, 0xfc0);
+        bytes.writeUInt32LE(16, 0xfc8);
+        bytes.writeBigUInt64LE(base + 0x450n, 0xfd8);
+      } else {
+        bytes.writeBigUInt64LE(base + 0xfd8n, 0xb00);
+        bytes.writeBigUInt64LE(base + 0xbc0n, 0xfd8);
+        bytes.writeBigUInt64LE(base + 0x200n, 0xfe0);
+      }
+      const result = decodeAppleDispatchMetadata(bytes, 100, provenance);
+      if (owner === "class")
+        expect(result.objc_classes).toContainEqual(
+          expect.objectContaining({ name: "Fixture", is_meta_class: false }),
+        );
+      else
+        expect(result.objc_categories).toMatchObject([
+          { name: "FixtureCategory", class_name: "Fixture", properties: [] },
+        ]);
+      expect(
+        result.coverage.find(
+          ({ facet }) => facet === "objc_properties_categories",
+        ),
+      ).toMatchObject({
+        status: "partial",
+        reason: expect.stringContaining(
+          "property_decode_failed at 0x100001000",
+        ),
+      });
+    },
+  );
+
   it.each([
     ["an unmapped name", { secondNameOffset: 0x2000 }, "first", "0x100000518"],
     ["an empty name", { firstName: "" }, "second", "0x100000508"],

src/native/AppleMachoFixups.test.ts

@@ -209,6 +209,7 @@ it.each(["bind", "weak", "lazy"] as const)(
       "base64",
     );
     const opcodes = Buffer.from([
+      0x51,
       0x11,
       0x40,
       ...Buffer.from("_first\0"),
@@ -354,6 +355,7 @@ it.each(["bind", "weak", "lazy"] as const)(
     ]);
     const literalName = "_OBJC_CLASS_$_�";
     const opcodes = Buffer.from([
+      0x51,
       0x11,
       0x71,
       0x08,
@@ -806,6 +808,7 @@ describe("incomplete legacy bind applicability", () => {
 
   it("retains a positive bind prefix while leaving unmatched slots unknown", () => {
     const opcodes = Buffer.from([
+      0x51,
       0x11,
       0x40,
       ...Buffer.from("_x\0"),
@@ -1085,11 +1088,20 @@ describe("parsed chained pointer membership", () => {
         target: BASE + 0x4321n,
       },
     );
-    const plain = data.readBigUInt64LE(0x400b);
-    expect(fixups.decode(BASE + 0x400bn, plain)).toEqual({
-      kind: "raw",
-      target: plain,
-    });
+    for (const offset of [0x4002, 0x400b, 0x4012])
+      expect(
+        fixups.decode(BASE + BigInt(offset), data.readBigUInt64LE(offset)),
+      ).toEqual({
+        kind: "unsupported",
+        reason: "A chained fixup partially overlaps the pointer slot",
+      });
+    for (const offset of [0x4000, 0x4019]) {
+      const plain = data.readBigUInt64LE(offset);
+      expect(fixups.decode(BASE + BigInt(offset), plain)).toEqual({
+        kind: "raw",
+        target: plain,
+      });
+    }
   });
 
   it.each(["shared", "exhausted"])(
@@ -1613,6 +1625,85 @@ it("keeps both pointer slots unresolved when a legacy bind overlaps them", () =>
   expect(fixups.decode(BASE + 0x4008n, 456n).kind).toBe("unsupported");
 });
 
+describe("legacy bind write types", () => {
+  it.each([2, 3])(
+    "keeps four-byte bind type %i unresolved without claiming writes to adjacent bytes",
+    (type) => {
+      const opcodes = Buffer.from([
+        0x50 | type,
+        0x11,
+        0x40,
+        ...Buffer.from("_text\0"),
+        0x71,
+        0x08,
+        0x90,
+        0x51,
+        0x90,
+        0,
+      ]);
+      const bytes = Buffer.alloc(0x8000);
+      opcodes.copy(bytes, 0x7000);
+      const fixups = parsePointerFixups(
+        bytes,
+        {
+          chained: null,
+          rebases: [],
+          binds: [{ offset: 0x7000, size: opcodes.length, stream: "bind" }],
+          dylibs: ["/library"],
+        },
+        SEGMENTS,
+        BASE,
+      );
+      expect(fixups.decode(BASE + 0x4008n, 0n)).toMatchObject({
+        kind: "unsupported",
+        reason: "Legacy non-pointer bind is not a 64-bit metadata pointer",
+      });
+      expect(fixups.decode(BASE + 0x400cn, 0x1234n)).toEqual({
+        kind: "unsupported",
+        reason: "A legacy fixup partially overlaps the pointer slot",
+      });
+      expect(fixups.hasUnresolvedLegacyBytes(BASE + 0x400bn, 1)).toBe(true);
+      expect(fixups.hasUnresolvedLegacyBytes(BASE + 0x400cn, 4)).toBe(false);
+      expect(fixups.decode(BASE + 0x4010n, 0n)).toMatchObject({
+        kind: "bind",
+        symbol: "_text",
+      });
+      expect(fixups.issues).toMatchObject([{ code: "non_pointer_bind" }]);
+      expect(fixups.decoded).toBe(1);
+    },
+  );
+
+  it.each(["bind", "weak", "lazy"] as const)(
+    "preserves %s type defaults instead of inventing a pointer bind",
+    (stream) => {
+      const opcodes = Buffer.from([
+        0x11,
+        0x40,
+        ...Buffer.from("_x\0"),
+        0x71,
+        0x08,
+        0x90,
+        0,
+      ]);
+      const fixups = parsePointerFixups(
+        opcodes,
+        {
+          chained: null,
+          rebases: [],
+          binds: [{ offset: 0, size: opcodes.length, stream }],
+          dylibs: ["/library"],
+        },
+        SEGMENTS,
+        BASE,
+      );
+      expect(fixups.decode(BASE + 0x4008n, 0n).kind).toBe(
+        stream === "lazy" ? "bind" : "unknown",
+      );
+      expect(fixups.decoded).toBe(stream === "lazy" ? 1 : 0);
+    },
+  );
+});
+
 describe("legacy pointer fixup streams", () => {
   it("interprets legacy bind, weak-bind and lazy-bind opcodes", () => {
     const opcodes = Buffer.from([
@@ -1685,6 +1776,7 @@ describe("legacy pointer fixup streams", () => {
     // The unsigned 64-bit encoding of -8 revisits the current pointer slot.
     const back = [0xf8, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01];
     const opcodes = Buffer.from([
+      0x51,
       0x11, // SET_DYLIB_ORDINAL_IMM 1
       0x40,
       ...Buffer.from("__ZdlPv\0"),
@@ -1724,6 +1816,7 @@ describe("legacy pointer fixup streams", () => {
 
   it("retains weak-bind stream provenance independently from its default ordinal", () => {
     const opcodes = Buffer.from([
+      0x51,
       0x40,
       ...Buffer.from("_OBJC_CLASS_$_NSObject\0"),
       0x71,
@@ -1754,6 +1847,7 @@ describe("legacy pointer fixup streams", () => {
 describe("legacy bind operand decoding", () => {
   const addendStream = (addend: readonly number[]) =>
     Buffer.from([
+      0x51,
       0x11, // SET_DYLIB_ORDINAL_IMM 1
       0x40,
       ...Buffer.from("_x\0"),
@@ -1859,6 +1953,7 @@ describe("legacy bind operand decoding", () => {
 
   const addressStream = (operand: readonly number[]) =>
     Buffer.from([
+      0x51,
       0x40,
       ...Buffer.from("_x\0"),
       0x71,
@@ -1907,6 +2002,7 @@ it("preserves classic special ordinals and returns unsupported at invalid bind l
   const parseOrdinal = (ordinal: number, dylibs: readonly string[]) => {
     const immediate = ordinal < 0 ? ordinal + 16 : ordinal;
     const opcodes = Buffer.from([
+      0x51,
       ordinal > 0 ? 0x10 | ordinal : 0x30 | immediate,
       0x40,
       ...Buffer.from("_OBJC_CLASS_$_NSObject\0"),
@@ -1955,6 +2051,7 @@ it("preserves classic special ordinals and returns unsupported at invalid bind l
   }
   encoded.push(Number(remaining));
   const oversizedStream = Buffer.from([
+    0x51,
     0x20,
     ...encoded,
     0x40,

src/native/AppleMachoFixups.ts

@@ -116,6 +116,8 @@ interface BindRun {
   readonly start: bigint;
   count: bigint;
   readonly stride: bigint;
+  readonly type: number;
+  readonly width: 4 | 8;
   readonly binding:
     | {
         readonly kind: "bind";
@@ -377,6 +379,28 @@ const readChainedPage = (
   return { locations, lastOffset, failure };
 };
 
+/** A known eight-byte chain word starting elsewhere overlaps this pointer read. */
+const hasPartialChainedPointer = (
+  chain: ChainedSegment,
+  within: number,
+  readPage: (page: number) => ChainedPage | null,
+): boolean => {
+  let page = -1;
+  let facts: ChainedPage | null = null;
+  for (let at = Math.max(0, within - 7); at <= within + 7; at++) {
+    if (at === within || BigInt(at) >= chain.segment.size) continue;
+    const candidatePage = Math.floor(at / chain.pageSize);
+    if (candidatePage !== page) {
+      page = candidatePage;
+      facts = readPage(page);
+    }
+    const offset = at % chain.pageSize;
+    if (((facts?.locations[offset >>> 3] ?? 0) & (1 << (offset & 7))) !== 0)
+      return true;
+  }
+  return false;
+};
+
 const chainedFixups = (
   image: FixupImage,
   range: { readonly offset: number; readonly size: number },
@@ -654,6 +678,45 @@ const chainedFixups = (
           raw,
           reason: `Legacy bind opcodes could overlap this rebase location: ${binds.failures.join("; ")}`,
         };
+      // Reuse one transient view within this lookup even when retained page
+      // storage is full; overlap inspection and value decoding share its facts.
+      let queried:
+        | { chain: ChainedSegment; page: number; facts: ChainedPage }
+        | undefined;
+      const queryPageFacts = (
+        chain: ChainedSegment,
+        page: number,
+        start: number,
+      ): ChainedPage => {
+        if (queried?.chain === chain && queried.page === page)
+          return queried.facts;
+        const facts = pageFacts(chain, page, start);
+        queried = { chain, page, facts };
+        return facts;
+      };
+      if (
+        ranges.some(
+          (chain) =>
+            POINTER_FORMATS[chain.format] !== undefined &&
+            address + 8n > chain.segment.address &&
+            address < chain.segment.address + chain.segment.size &&
+            hasPartialChainedPointer(
+              chain,
+              Number(address - chain.segment.address),
+              (page) => {
+                if (page >= chain.pageCount) return null;
+                const start = bytes.readUInt16LE(chain.pageStarts + page * 2);
+                return start === 0xffff
+                  ? null
+                  : queryPageFacts(chain, page, start);
+              },
+            ),
+        )
+      )
+        return {
+          kind: "unsupported",
+          reason: "A chained fixup partially overlaps the pointer slot",
+        };
       const chainIndex = ranges.findIndex(
         ({ segment }) =>
           address >= segment.address &&
@@ -675,7 +738,7 @@ const chainedFixups = (
           reason: `Unsupported chained pointer format ${chain.format}`,
         };
       try {
-        const facts = pageFacts(chain, page, start);
+        const facts = queryPageFacts(chain, page, start);
         const at = within % chain.pageSize;
         const locations = facts.locations;
         if (((locations[at >>> 3] ?? 0) & (1 << (at & 7))) !== 0) {
@@ -1022,6 +1085,7 @@ const sleb = (bytes: Buffer, cursor: { at: number }, end: number): bigint => {
 
 /** Registers of the `LC_DYLD_INFO` bind state machine. */
 interface BindState {
+  type: number;
   ordinal: number;
   ordinalFailure: string | null;
   segmentIndex: number;
@@ -1072,6 +1136,7 @@ const setBindRegister = (
       return true;
     }
     case 0x50:
+      state.type = immediate;
       return true;
     case 0x60:
       state.addend = sleb(bytes, cursor, end);
@@ -1106,6 +1171,7 @@ function* readBindStreamSteps(
     throw new RangeError("Bind opcodes exceed the target");
   const cursor = { at: range.offset };
   const state: BindState = {
+    type: range.stream === "lazy" ? 1 : 0,
     ordinal: 0,
     ordinalFailure: null,
     segmentIndex: -1,
@@ -1116,11 +1182,14 @@ function* readBindStreamSteps(
   };
   const preflightRun = (count: bigint, skip: bigint): void => {
     if (count === 0n) return;
+    if (state.type < 1 || state.type > 3)
+      throw new RangeError(`Unsupported legacy bind type ${state.type}`);
     const segment = image.segments[state.segmentIndex];
     if (segment === undefined)
       throw new RangeError("Bind location has no selected segment");
     const stride = 8n + skip;
-    const end = state.address + (count - 1n) * stride + 8n;
+    const width = state.type === 1 ? 8n : 4n;
+    const end = state.address + (count - 1n) * stride + width;
     if (state.address < segment.address || end > segment.address + segment.size)
       throw new RangeError("Bind expansion leaves its file-backed segment");
   };
@@ -1128,22 +1197,29 @@ function* readBindStreamSteps(
     if (count === 0n) return;
     preflightRun(count, skip);
     const stride = 8n + skip;
+    const width = state.type === 1 ? 8 : 4;
     let binding: BindRun["binding"];
     try {
       if (state.ordinalFailure !== null)
         throw new RangeError(state.ordinalFailure);
       const resolvedLibrary = libraryFacts(state.ordinal, image.dylibs);
-      const decoded = resolvedBind(
-        {
-          ...state.symbol,
-          binding_source: range.stream,
-          library_ordinal: state.ordinal,
-          ...(range.stream === "weak" ? { library: null } : resolvedLibrary),
-          weak: state.weak,
-          addend: state.addend,
-        },
-        0n,
-      );
+      const imported: Import = {
+        ...state.symbol,
+        binding_source: range.stream,
+        library_ordinal: state.ordinal,
+        ...(range.stream === "weak" ? { library: null } : resolvedLibrary),
+        weak: state.weak,
+        addend: state.addend,
+      };
+      const decoded =
+        state.type === 1
+          ? resolvedBind(imported, 0n)
+          : {
+              kind: "unsupported" as const,
+              reason:
+                "Legacy non-pointer bind is not a 64-bit metadata pointer",
+              binding: imported,
+            };
       binding =
         decoded.kind === "bind" ? { kind: "bind", value: decoded } : decoded;
     } catch (cause: unknown) {
@@ -1167,13 +1243,21 @@ function* readBindStreamSteps(
           : false;
     if (
       previous !== undefined &&
+      previous.type === state.type &&
       previous.stride === stride &&
       previous.start + previous.count * stride === state.address &&
       sameBinding(previous.binding, binding)
     ) {
       previous.count += count;
     } else {
-      binds.push({ start: state.address, count, stride, binding });
+      binds.push({
+        start: state.address,
+        count,
+        stride,
+        type: state.type,
+        width,
+        binding,
+      });
     }
     // The dyld bind stream advances addresses modulo 64 bits; ld uses -8 to
     // bind the current pointer slot again with DO_BIND_ADD_ADDR_ULEB.
@@ -1237,6 +1321,18 @@ const indexBindRuns = (
   };
 };
 
+/** First producer-owned bind start in an inclusive address interval. */
+const firstBindIn = (
+  run: BindRun,
+  low: bigint,
+  high: bigint,
+): bigint | undefined => {
+  const index =
+    low <= run.start ? 0n : (low - run.start + run.stride - 1n) / run.stride;
+  const address = run.start + index * run.stride;
+  return index < run.count && address <= high ? address : undefined;
+};
+
 /** Visit runs with a bind start in the inclusive interval, without expanding runs. */
 function* bindRunsIn(
   index: BindRunIndex,
@@ -1263,9 +1359,7 @@ function* bindRunsIn(
     index.remaining--;
     candidates++;
     const run = index.runs[at]!;
-    const first =
-      low <= run.start ? 0n : (low - run.start + run.stride - 1n) / run.stride;
-    if (first < run.count && run.start + first * run.stride <= high) yield run;
+    if (firstBindIn(run, low, high) !== undefined) yield run;
   }
 }
 
@@ -1318,9 +1412,11 @@ function* parseLegacyBindsSteps(
     issues.push(
       issue(
         "pointer_fixups",
-        run.binding.binding.symbol === null
-          ? "bind_symbol_text_unavailable"
-          : "bind_library_text_unavailable",
+        run.type !== 1
+          ? "non_pointer_bind"
+          : run.binding.binding.symbol === null
+            ? "bind_symbol_text_unavailable"
+            : "bind_library_text_unavailable",
         run.binding.reason,
         `0x${run.start.toString(16)}`,
       ),
@@ -1350,7 +1446,11 @@ const hasUnresolvedLegacyBytes = (
     return true;
   const first = address - 7n;
   const end = address + BigInt(size);
-  for (const _run of bindRunsIn(binds.index, first, end - 1n)) return true;
+  for (const run of bindRunsIn(binds.index, first, end - 1n))
+    if (
+      firstBindIn(run, address - BigInt(run.width) + 1n, end - 1n) !== undefined
+    )
+      return true;
   if (binds.index.exhausted) return true;
   if (rebases.membership !== null)
     for (let slot = first; slot < end; slot++) {
@@ -1376,10 +1476,13 @@ const hasPartialLegacyPointerWrite = (
   const low = address - 7n;
   const high = address + 7n;
   for (const run of bindRunsIn(binds.index, low, high)) {
-    const first =
-      low <= run.start ? 0n : (low - run.start + run.stride - 1n) / run.stride;
-    const at = run.start + first * run.stride;
-    if (at !== address || (first + 1n < run.count && at + run.stride <= high))
+    const at = firstBindIn(run, address - BigInt(run.width) + 1n, high);
+    if (at === undefined) continue;
+    if (
+      run.width !== 8 ||
+      at !== address ||
+      firstBindIn(run, at + 1n, high) !== undefined
+    )
       return true;
   }
   if (binds.index.exhausted) return true;

src/native/AppleMachoSelection.test.ts

@@ -234,6 +234,7 @@ describe("Mach-O metadata span mapping", () => {
     const opcodes = Buffer.from([
       0x40,
       ...Buffer.from("_local\0"),
+      0x51,
       0x72,
       8,
       0x90,
@@ -340,6 +341,19 @@ describe("Mach-O metadata span mapping", () => {
   });
 });
 
+it("rejects a segment command of the wrong width before claiming metadata absence", () => {
+  const segment = Buffer.alloc(56);
+  segment.writeUInt32LE(1, 0);
+  segment.writeUInt32LE(segment.length, 4);
+  const bytes = Buffer.from(machoImage({ commands: [segment] }));
+  expect(() => readMachoMetadataImage(bytes)).toThrow(
+    "Mach-O segment command does not match the header width",
+  );
+  expect(() => parseMachoLayout(bytes, "arm64")).toThrow(
+    "Mach-O segment command does not match the header width",
+  );
+});
+
 describe("native Mach-O slice selection", () => {
   it("rejects misaligned load commands", () => {
     expect(() =>

src/native/AppleMachoSelection.ts

@@ -227,6 +227,10 @@ export const parseMachoLayout = (
       kind: frame.value.command,
       size: frame.value.size,
     };
+    if (command.kind === 1)
+      throw new RangeError(
+        "Mach-O segment command does not match the header width",
+      );
     if (command.kind === 0x19) collectSegment(bytes, command, state);
     else collectFixupCommand(bytes, command, state);
   }

src/native/AppleObjcCategories.ts

@@ -134,17 +134,12 @@ export const decodeObjcCategories = (input: {
               `0x${(category + 32n).toString(16)}`,
             ),
           );
-        const properties = readObjcPropertiesOf(
-          read,
-          read.pointer(category + 40n),
-          {
-            owner: `category ${name}`,
-            admit: input.admit,
-            issues: input.issues,
-            location: `0x${read.pointer(category + 40n).toString(16)}`,
-            onTruncated,
-          },
-        );
+        const properties = readObjcPropertiesOf(read, category + 40n, {
+          owner: `category ${name}`,
+          admit: input.admit,
+          issues: input.issues,
+          onTruncated,
+        });
         const decodeReasons = [
           ...(className === null ? ["category_class_unresolved"] : []),
           ...(protocols.ok ? [] : ["protocol_list_unreadable"]),

src/native/AppleObjcDispatchFacets.ts

@@ -354,11 +354,10 @@ export const decodeObjcDispatchFacets = (input: {
       undefined,
       onTruncated,
     );
-    const properties = readObjcPropertiesOf(read, read.pointer(ro + 64n), {
+    const properties = readObjcPropertiesOf(read, ro + 64n, {
       owner: name,
       admit: () => budget.admit(),
       issues: categoryIssues,
-      location: hex(read.pointer(ro + 64n)),
       onTruncated,
     });
     const adoptedProtocols = protocolReader.readList(ro + 40n, onTruncated);

src/native/AppleObjcProperties.ts

@@ -154,19 +154,21 @@ export const readObjcPropertyList = (
   return { properties, issues };
 };
 
-/** Decode a property list, recording a failure for `owner` instead of throwing. */
+/** Own the property-list pointer field and list, retaining the declaring owner on failure. */
 export const readObjcPropertiesOf = (
   read: ObjcPropertyReaders,
-  list: bigint,
+  field: bigint,
   context: {
     readonly owner: string;
     readonly admit: () => boolean;
     readonly issues: DecodeIssue[];
-    readonly location?: string;
     readonly onTruncated?: () => void;
   },
 ): ObjcProperty[] => {
+  let location = `0x${field.toString(16)}`;
   try {
+    const list = read.pointer(field);
+    location = `0x${list.toString(16)}`;
     const { properties, issues } = readObjcPropertyList(
       read,
       list,
@@ -189,7 +191,7 @@ export const readObjcPropertiesOf = (
         "objc_properties_categories",
         "property_decode_failed",
         `${context.owner}: ${cause instanceof Error ? cause.message : String(cause)}`,
-        context.location,
+        location,
       ),
     );
     return [];

src/native/AppleSwiftDispatchFacets.ts

@@ -234,9 +234,29 @@ export const createSwiftRelativeReader = (input: {
           );
     let fileOffset: number | null = null;
     let reason: string | null = null;
+    const unknownIndirect = (reason: string): SwiftRelativeValue => {
+      if (budget.admit())
+        result.relative_pointers.push({
+          field: read.location(field),
+          target: { address: null, file_offset: null },
+          displacement,
+          indirectable,
+          indirect,
+          decode: { status: "partial", reason },
+          evidence: read.evidence(field, "Swift ABI indirect relative pointer"),
+        });
+      return { kind: "unknown", reason };
+    };
     try {
       if (indirect && target !== null) {
-        const pointer = read.resolvePointer(target);
+        let pointer: PointerResolution;
+        try {
+          pointer = read.resolvePointer(target);
+        } catch (cause) {
+          const failure = expectedSwiftMetadataReadFailure(cause);
+          if (failure === null) throw cause;
+          return unknownIndirect(failure);
+        }
         if (pointer.kind === "bind") {
           if (budget.admit())
             result.relative_pointers.push({
@@ -259,21 +279,7 @@ export const createSwiftRelativeReader = (input: {
           };
         }
         if (pointer.kind === "unknown" || pointer.kind === "unsupported") {
-          const unresolved = pointer.reason;
-          if (budget.admit())
-            result.relative_pointers.push({
-              field: read.location(field),
-              target: { address: null, file_offset: null },
-              displacement,
-              indirectable,
-              indirect,
-              decode: { status: "partial", reason: unresolved },
-              evidence: read.evidence(
-                field,
-                "Swift ABI indirect relative pointer",
-              ),
-            });
-          return { kind: "unknown", reason: unresolved };
+          return unknownIndirect(pointer.reason);
         }
         const indirectTarget = pointer.target;
         target =
@@ -283,7 +289,8 @@ export const createSwiftRelativeReader = (input: {
       }
       if (target !== null) fileOffset = read.offset(target);
     } catch (cause) {
-      reason = cause instanceof Error ? cause.message : String(cause);
+      reason = expectedSwiftMetadataReadFailure(cause);
+      if (reason === null) throw cause;
     }
     if (budget.admit())
       result.relative_pointers.push({
@@ -553,7 +560,8 @@ export const decodeSwiftDispatchFacets = (input: {
           }
         }
       } catch (cause) {
-        const message = cause instanceof Error ? cause.message : String(cause);
+        const message = expectedSwiftMetadataReadFailure(cause);
+        if (message === null) throw cause;
         issues.push(
           issue(
             "swift_conformances_static_witness_slots",

src/native/AppleSwiftRelativePointer.test.ts

@@ -276,3 +276,37 @@ it("retains unsafe target addresses as partial decode facts", () => {
     decode: { status: "partial", reason: "outside fixture bytes" },
   });
 });
+
+it.each([
+  new RangeError("indirect pointer cell is unreadable"),
+  new Error("reader invariant failed"),
+])(
+  "distinguishes indirect pointer read failure from a known unmapped target: %s",
+  (failure) => {
+    const bytes = Buffer.alloc(0x80);
+    bytes.writeInt32LE(0x25, 0x24);
+    const result = objcSwiftMetadataSchema.parse({ db_save_result: null });
+    const relative = createSwiftRelativeReader({
+      bytes,
+      readers: {
+        ...readers(bytes),
+        resolvePointer: () => {
+          throw failure;
+        },
+      },
+      budget: budget(),
+      result,
+    });
+    if (failure instanceof RangeError) {
+      expect(relative(0x24n, "conformanceProtocol")).toEqual({
+        kind: "unknown",
+        reason: failure.message,
+      });
+      expect(result.relative_pointers[0]).toMatchObject({
+        target: { address: null, file_offset: null },
+        decode: { status: "partial", reason: failure.message },
+      });
+    } else
+      expect(() => relative(0x24n, "conformanceProtocol")).toThrow(failure);
+  },
+);

src/native/AppleSwiftVtables.test.ts

@@ -9,9 +9,66 @@ import {
   type SwiftNominalReaders,
 } from "./AppleSwiftNominalTypes.js";
 import { decodeSwiftDispatchFacets } from "./AppleSwiftDispatchFacets.js";
-import type { DispatchRecordBudget } from "./AppleSwiftDispatchFacets.js";
+import type {
+  DispatchRecordBudget,
+  SwiftDispatchReaders,
+} from "./AppleSwiftDispatchFacets.js";
 import { issue } from "./AppleDispatchDecodeFacts.js";
 
+it("propagates unexpected conformance reader failures", () => {
+  const failure = new Error("conformance reader invariant failed");
+  expect(() =>
+    decodeSwiftDispatchFacets({
+      sections: [{ name: "__swift5_proto", address: 0x100n, size: 4 }],
+      segments: [],
+      readers: {} as SwiftDispatchReaders,
+      relative: () => {
+        throw failure;
+      },
+      budget: {
+        truncated: false,
+        isFull: () => false,
+        markTruncated: () => {},
+        admit: () => true,
+      },
+      result: objcSwiftMetadataSchema.parse({ db_save_result: null }),
+    }),
+  ).toThrow(failure);
+});
+
+it("propagates unexpected vtable reader failures", () => {
+  const failure = new Error("vtable reader invariant failed");
+  const vtables = createSwiftClassVtableDecoder({
+    result: objcSwiftMetadataSchema.parse({ db_save_result: null }),
+    readers: {
+      u32: () => {
+        throw failure;
+      },
+      relative: () => ({ kind: "null" }),
+      location: () => ({ address: null, file_offset: null }),
+      evidence: () => [],
+      executable: () => false,
+      admit: () => true,
+    },
+  });
+  expect(() =>
+    vtables.visitor.descriptor({
+      record: 0x100n,
+      descriptor: 0x200n,
+      flags: 0x80000010,
+      name: "Widget",
+      context: {
+        module: "Test",
+        path: "Widget",
+        depth: 2,
+        anonymous: false,
+        reason: null,
+        walkLimited: false,
+      },
+    }),
+  ).toThrow(failure);
+});
+
 it("preserves unsupported type-metadata tag reasons instead of reporting null", () => {
   const result = objcSwiftMetadataSchema.parse({ db_save_result: null });
   const vtables = createSwiftClassVtableDecoder({

src/native/AppleSwiftVtables.ts

@@ -14,6 +14,7 @@ import type {
   SwiftNominalRecordFailure,
   SwiftNominalVisitor,
 } from "./AppleSwiftNominalTypes.js";
+import { expectedSwiftMetadataReadFailure } from "./AppleSwiftMetadataReadFailure.js";
 
 /** Byte readers shared with the validated Mach-O metadata boundary. */
 export interface SwiftMetadataReaders {
@@ -63,13 +64,13 @@ export const createSwiftClassVtableDecoder = (input: {
     try {
       const specific = flags >>> 16;
       if ((flags & 0x80) !== 0 || (specific & 0x2000) !== 0)
-        throw new TypeError(
+        throw new RangeError(
           "Generic class or resilient superclass metadata is unsupported",
         );
       if ((specific & 0x8000) === 0) return;
       const initialization = specific & 3;
       if (initialization === 3)
-        throw new TypeError("Unknown metadata initialization kind");
+        throw new RangeError("Unknown metadata initialization kind");
       const header =
         descriptor +
         44n +
@@ -167,7 +168,8 @@ export const createSwiftClassVtableDecoder = (input: {
         );
       }
     } catch (cause) {
-      const message = cause instanceof Error ? cause.message : String(cause);
+      const message = expectedSwiftMetadataReadFailure(cause);
+      if (message === null) throw cause;
       issues.push(
         issue(
           "swift_class_vtable_descriptors",

src/native/MachoCommandNames.ts

@@ -214,15 +214,44 @@ export const readMachoCommandNames = async (
   chargeProjection(table.commandCount, PROJECTED_COMMAND_BYTES);
   let records = table.commandCount;
   let retainedStringBytes = 0;
-  const retain = (bytes: Uint8Array): Uint8Array => {
-    if (bytes.byteLength > maximumStringBytes - retainedStringBytes)
+  const stringAllowance = (): number =>
+    Math.min(
+      maximumStringBytes - retainedStringBytes,
+      Math.floor(
+        (maximumProjectedBytes - projectedBytes) / PROJECTED_STRING_EXPANSION,
+      ),
+    );
+  const admitStringBytes = (count: number): void => {
+    if (count > maximumStringBytes - retainedStringBytes)
       throw new MachoCommandNamesLimitError(maximumStringBytes, "bytes");
+    if (count > stringAllowance())
+      throw new MachoCommandNamesLimitError(
+        maximumProjectedBytes,
+        "projected_bytes",
+      );
+  };
+  const retain = (bytes: Uint8Array): Uint8Array => {
+    admitStringBytes(bytes.byteLength);
     chargeProjection(bytes.byteLength, PROJECTED_STRING_EXPANSION);
     retainedStringBytes += bytes.byteLength;
     // Range readers may return Buffer views into a much larger read window.
     // Charge the retained length before allocating an independently owned copy.
     return Uint8Array.from(bytes);
   };
+  const readString = async (
+    offset: number,
+    extent: number,
+    label: string,
+  ): Promise<Uint8Array> => {
+    const length = Math.min(extent, stringAllowance() + 1);
+    const bytes = await exact(offset, length);
+    const end = bytes.indexOf(0);
+    if (end < 0) {
+      if (length < extent) admitStringBytes(length);
+      throw new MachoBinaryFormatError(`${label} is unterminated`);
+    }
+    return retain(bytes.subarray(0, end));
+  };
   const commands: MachoCommandNames["commands"][number][] = [];
   while (cursor.nextOffset !== null) {
     const row = cursor.read(
@@ -372,17 +401,11 @@ export const readMachoCommandNames = async (
         throw new MachoBinaryFormatError(
           "Mach-O command string offset is invalid",
         );
-      const limit = Math.min(frame.size - offset, maximumStringBytes + 1);
-      const bytes = await exact(at + offset, limit);
-      const end = bytes.indexOf(0);
-      if (end < 0) {
-        if (limit < frame.size - offset)
-          throw new MachoCommandNamesLimitError(maximumStringBytes, "bytes");
-        throw new MachoBinaryFormatError(
-          "Mach-O command string is unterminated",
-        );
-      }
-      commandString = retain(bytes.subarray(0, end));
+      commandString = await readString(
+        at + offset,
+        frame.size - offset,
+        "Mach-O command string",
+      );
       commandStringOffset = offset;
       if (DYLIB_COMMANDS.has(frame.command)) {
         const fixed = await exact(at + 12, 12);
@@ -434,8 +457,7 @@ export const readMachoCommandNames = async (
         throw new MachoBinaryFormatError(
           "Mach-O prebound module bitmap exceeds its command",
         );
-      if (length > maximumStringBytes - retainedStringBytes)
-        throw new MachoCommandNamesLimitError(maximumStringBytes, "bytes");
+      admitStringBytes(length);
       prebound = {
         moduleCount,
         linkedModulesOffset,
@@ -501,12 +523,8 @@ export const readMachoCommandNames = async (
             currentLength = 0;
             if (linkerOptions.length === count) break;
           } else {
-            const remaining = maximumStringBytes - retainedStringBytes;
-            if (currentLength >= remaining)
-              throw new MachoCommandNamesLimitError(
-                maximumStringBytes,
-                "bytes",
-              );
+            const remaining = stringAllowance();
+            if (currentLength >= remaining) admitStringBytes(currentLength + 1);
             if (currentLength === current.byteLength) {
               const capacity = Math.min(
                 remaining,
@@ -565,20 +583,14 @@ export const readMachoCommandNames = async (
         throw new MachoBinaryFormatError(
           "Mach-O fileset entry string offset is invalid",
         );
-      const length = Math.min(frame.size - offset, maximumStringBytes + 1);
-      const value = await exact(at + offset, length);
-      const end = value.indexOf(0);
-      if (end < 0) {
-        if (length < frame.size - offset)
-          throw new MachoCommandNamesLimitError(maximumStringBytes, "bytes");
-        throw new MachoBinaryFormatError(
-          "Mach-O fileset entry string is unterminated",
-        );
-      }
       fileset = {
         address: view.getBigUint64(0, table.littleEndian),
         fileOffset: view.getBigUint64(8, table.littleEndian),
-        entryId: retain(value.subarray(0, end)),
+        entryId: await readString(
+          at + offset,
+          frame.size - offset,
+          "Mach-O fileset entry string",
+        ),
         reserved: view.getUint32(20, table.littleEndian),
       };
     }

src/native/MachoProjectionBudget.test.ts

@@ -100,3 +100,69 @@ it("reserves the projection envelope for an empty command table", async () => {
     });
   }
 });
+
+it("bounds a growing linker option before reading its remaining payload", async () => {
+  const commandSize = 8208;
+  const image = Buffer.alloc(32 + commandSize);
+  image.writeUInt32LE(0xfeedfacf, 0);
+  image.writeUInt32LE(1, 16);
+  image.writeUInt32LE(commandSize, 20);
+  image.writeUInt32LE(0x2d, 32);
+  image.writeUInt32LE(commandSize, 36);
+  image.writeUInt32LE(1, 40);
+  image.fill(0x41, 44, 44 + 8000);
+  const projectedBudget = 8192 + 2048 + 256 + 32 * 24;
+  const read = async (offset: number, size: number) => {
+    if (offset >= 44 + 4096)
+      throw new Error("linker option read beyond its projection allowance");
+    return image.subarray(offset, offset + size);
+  };
+  await expect(
+    readMachoCommandNames(read, image.length, 16384, 2, projectedBudget),
+  ).rejects.toMatchObject({
+    maximum: projectedBudget,
+    unit: "projected_bytes",
+  });
+});
+
+it.each([
+  ["rpath", 0x8000001c, 12],
+  ["fileset", 0x80000035, 32],
+] as const)(
+  "bounds %s strings before reading their declared extent",
+  async (_name, command, nameOffset) => {
+    const commandSize = 8208;
+    const image = Buffer.alloc(32 + commandSize);
+    image.writeUInt32LE(0xfeedfacf, 0);
+    image.writeUInt32LE(1, 16);
+    image.writeUInt32LE(commandSize, 20);
+    image.writeUInt32LE(command, 32);
+    image.writeUInt32LE(commandSize, 36);
+    image.writeUInt32LE(nameOffset, command === 0x80000035 ? 56 : 40);
+    const stringAt = 32 + nameOffset;
+    image.fill(0x41, stringAt, stringAt + 8000);
+    const projectedBudget = 8192 + 2048 + 32 * 24;
+    const read = async (offset: number, size: number) => {
+      if (offset === stringAt && size > 33)
+        throw new Error("string read beyond its projection allowance");
+      return image.subarray(offset, offset + size);
+    };
+    await expect(
+      readMachoCommandNames(read, image.length, 16384, 1, projectedBudget),
+    ).rejects.toMatchObject({
+      maximum: projectedBudget,
+      unit: "projected_bytes",
+    });
+    image[stringAt + 32] = 0;
+    const parsed = await readMachoCommandNames(
+      async (offset, size) => image.subarray(offset, offset + size),
+      image.length,
+      16384,
+      1,
+      projectedBudget,
+    );
+    const name =
+      parsed.commands[0]?.commandString ?? parsed.commands[0]?.fileset?.entryId;
+    expect(name).toHaveLength(32);
+  },
+);

src/native/NativeCommandDeadline.test.ts

@@ -1,11 +1,15 @@
 import { afterEach, describe, expect, it, vi } from "vitest";
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
 
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
+import { fat } from "../domain/binaryTarget.fixture.js";
 import type { JsonValue } from "../domain/jsonValue.js";
 import {
   NativeFixtureRunner,
-  nativeMachoTarget,
+  nativeMachoTargetForFile,
 } from "../../tests/fixtures/nativeCommands.js";
+import { createTestTempDirectory } from "../../tests/fixtures/temporaryDirectory.js";
 import {
   OwnedCommandFailure,
   runOwnedCommand,
@@ -45,8 +49,11 @@ const execute = async (
   runner: NativeCommandRunner,
   parameters: Readonly<Record<string, JsonValue>>,
 ) => {
+  const root = await createTestTempDirectory("rea-native-deadline-");
+  const path = join(root, "app");
+  await writeFile(path, fat([0x01000007, 0x0100000c]));
   const client = new NativeMacOSProvider({}, runner, "darwin").createClient(
-    nativeMachoTarget("/fixture/app"),
+    await nativeMachoTargetForFile(path),
   );
   try {
     return await client.execute("list_architectures", parameters);

src/native/NativeMacOSProvider.ts

@@ -141,6 +141,7 @@ import {
   inspectNativeMacho,
 } from "./NativeMachoInspection.js";
 import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
+import { analysisErrorWithCancellation } from "../domain/analysisErrorCancellation.js";
 import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
 import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
 import { projectAnalysisError } from "../domain/analysisErrorProjection.js";
@@ -654,13 +655,14 @@ class NativeMacOSClient implements AnalysisClient {
       case "inspect_plist":
         return this.#inspectPlist(parameters, signal, timeoutMs);
       case "list_architectures":
-        return this.#listArchitectures(signal, timeoutMs);
+        return this.#listArchitectures(parameters, signal, timeoutMs);
       case "demangle_swift":
         return this.#demangle(parameters, signal, timeoutMs);
     }
   }
 
   async #listArchitectures(
+    parameters: Readonly<Record<string, JsonValue>>,
     signal: AbortSignal | undefined,
     timeoutMs: number,
   ): Promise<Result<NativeObservation, AnalysisError>> {
@@ -674,39 +676,59 @@ class NativeMacOSClient implements AnalysisClient {
           "Active artifact is not Mach-O.",
         ),
       );
-    const capture = await this.#run(
-      "list_architectures",
-      "lipo",
-      ["-detailed_info", this.target.path],
-      { signal, timeoutMs },
-    );
-    if (!capture.ok) return capture;
-    const provenance = [invocation(capture.value, this.target.path)];
-    const parsed = parseLipoCapture(
-      capture.value,
-      "list_architectures",
-      this.target.path,
-    );
-    if (!parsed.ok) return parsed;
-    const { architectures } = parsed.value;
-    const limitations = architectures.flatMap(
-      (architecture) => architecture.limitations,
-    );
-    const result = listArchitecturesSchema.parse({
-      architectures: {
-        items: architectures,
-        total: architectures.length,
-        exhaustive: true,
-        limitations: [],
-      },
-      provenance,
-      limitations,
-    });
-    return ok({
-      result: jsonValueSchema.parse(result),
-      limitations,
-      locations: architectureLocations(result.architectures.items),
-    });
+    try {
+      return await this.#machoResources.run(() =>
+        withNativeMachoSource(
+          this.target,
+          this.#machoResources,
+          signal,
+          async () => {
+            const capture = await this.#run(
+              "list_architectures",
+              "lipo",
+              ["-detailed_info", this.target.path],
+              { signal, timeoutMs },
+            );
+            if (!capture.ok) return capture;
+            const provenance = [invocation(capture.value, this.target.path)];
+            const parsed = parseLipoCapture(
+              capture.value,
+              "list_architectures",
+              this.target.path,
+            );
+            if (!parsed.ok) return parsed;
+            const { architectures } = parsed.value;
+            const limitations = architectures.flatMap(
+              (architecture) => architecture.limitations,
+            );
+            const result = listArchitecturesSchema.parse({
+              architectures: {
+                items: architectures,
+                total: architectures.length,
+                exhaustive: true,
+                limitations: [],
+              },
+              provenance,
+              limitations,
+            });
+            return ok({
+              result: jsonValueSchema.parse(result),
+              limitations,
+              locations: architectureLocations(result.architectures.items),
+            });
+          },
+        ),
+      );
+    } catch (cause: unknown) {
+      return err(
+        nativeMachoSourceFailure(
+          cause,
+          this.target,
+          parameters,
+          "list_architectures",
+        ),
+      );
+    }
   }
 
   async #demangle(
@@ -1409,14 +1431,26 @@ class NativeMacOSClient implements AnalysisClient {
                 return await inspect(operand);
               } catch (cause: unknown) {
                 return err(
-                  nativeMachoSourceFailure(cause, this.target, parameters),
+                  nativeMachoSourceFailure(
+                    cause,
+                    this.target,
+                    parameters,
+                    "inspect_macho",
+                  ),
                 );
               }
             })
           : inspect(),
       );
     } catch (cause: unknown) {
-      return err(nativeMachoSourceFailure(cause, this.target, parameters));
+      return err(
+        nativeMachoSourceFailure(
+          cause,
+          this.target,
+          parameters,
+          "inspect_macho",
+        ),
+      );
     }
   }
 
@@ -1676,13 +1710,14 @@ const nativeMachoCompletedFailure = (
 const nativeMachoSourcePrimary = (
   { cause }: ArtifactFilePrimaryFacts,
   path: string,
+  operation: "inspect_macho" | "list_architectures",
 ): AnalysisError => {
   if (cause instanceof AnalysisError) return cause;
   if (cause instanceof MachoBinaryFormatError)
-    return new AnalysisOutputError("inspect_macho", cause.message, { cause });
+    return new AnalysisOutputError(operation, cause.message, { cause });
   if (cause instanceof MachoCommandNamesLimitError)
     return new AnalysisResourceConstraintError(
-      "inspect_macho",
+      operation,
       "memory",
       cause.message,
       { maximum: cause.maximum, unit: cause.unit },
@@ -1698,9 +1733,11 @@ const nativeMachoSourcePrimary = (
       ? nativeMachoSourcePrimary(
           artifactFilePrimaryFacts(cause.outcome.cause),
           path,
+          operation,
         )
       : undefined;
-  const previous = failed ?? nativeMachoCompletedFailure(completed);
+  const completedFailure = nativeMachoCompletedFailure(completed);
+  const previous = failed ?? completedFailure;
   const options = {
     cause,
     ...(previous === undefined
@@ -1713,21 +1750,31 @@ const nativeMachoSourcePrimary = (
           },
         }),
   };
-  if (cause instanceof ArtifactReaderFailure && cause.reason === "cancelled")
-    return new AnalysisCancelledError("inspect_macho", {
+  if (cause instanceof ArtifactReaderFailure && cause.reason === "cancelled") {
+    // A returned failure is already the producer's physical outcome. A later
+    // cancelled identity check must not replace its output or cleanup owner.
+    if (completedFailure !== undefined)
+      return analysisErrorWithCancellation(
+        completedFailure,
+        new AnalysisCancelledError(operation, {
+          cause: artifactFileCancellationCause(cause),
+        }),
+      );
+    return new AnalysisCancelledError(operation, {
       ...options,
       cause: artifactFileCancellationCause(cause),
     });
+  }
   if (cause instanceof ArtifactReaderFailure && cause.reason === "format")
-    return new AnalysisOutputError("inspect_macho", cause.message, options);
+    return new AnalysisOutputError(operation, cause.message, options);
   if (cause instanceof ArtifactReaderFailure && cause.reason === "integrity")
     return new AnalysisArtifactChangedError(
-      "inspect_macho",
+      operation,
       path,
       cause.message,
       options,
     );
-  return new ProviderAdapterError(IDENTITY.id, "inspect_macho", {
+  return new ProviderAdapterError(IDENTITY.id, operation, {
     ...options,
     userMessage: "The selected Mach-O source could not be read safely.",
     remediationAction:
@@ -1739,17 +1786,18 @@ const nativeMachoCompletion = (
   cause: unknown,
   target: BinaryTarget,
   parameters: Readonly<Record<string, JsonValue>>,
+  operation: "inspect_macho" | "list_architectures",
 ) => {
   const completion = artifactFileCompletion(cause);
   // The file operation only completes after the producer result has passed
-  // the final identity check. Its callback is owned by #inspectMacho.
+  // the final identity check. Both Mach-O command workflows own their callbacks.
   const outcome = completion?.value as
     | Result<NativeObservation, AnalysisError>
     | undefined;
   const observation =
     outcome?.ok === true
       ? createAnalysisExecutionEvidence(
-          "inspect_macho",
+          operation,
           parameters,
           {
             ...createAnalysisExecution(outcome.value.result, IDENTITY, {
@@ -1766,7 +1814,7 @@ const nativeMachoCompletion = (
   const completionCancellation =
     completion?.cancellation === undefined
       ? undefined
-      : new AnalysisCancelledError("inspect_macho", {
+      : new AnalysisCancelledError(operation, {
           cause: completion.cancellation.reason,
           ...(completedFailure === undefined ||
           (cause instanceof ArtifactReaderFailure &&
@@ -1787,9 +1835,10 @@ const nativeMachoSourceFailure = (
   cause: unknown,
   target: BinaryTarget,
   parameters: Readonly<Record<string, JsonValue>>,
+  operation: "inspect_macho" | "list_architectures",
 ): AnalysisError => {
   const { observation, completedFailure, completionCancellation } =
-    nativeMachoCompletion(cause, target, parameters);
+    nativeMachoCompletion(cause, target, parameters, operation);
   if (cause instanceof ArtifactReaderFailure && cause.cleanup !== undefined) {
     const physical =
       cause instanceof ArtifactFileCleanupFailure
@@ -1797,7 +1846,11 @@ const nativeMachoSourceFailure = (
         : undefined;
     const previous =
       physical?.outcome.kind === "failed"
-        ? nativeMachoSourcePrimary(artifactFilePrimaryFacts(cause), target.path)
+        ? nativeMachoSourcePrimary(
+            artifactFilePrimaryFacts(cause),
+            target.path,
+            operation,
+          )
         : physical?.outcome.kind === "completed"
           ? (completedFailure ?? completionCancellation)
           : completionCancellation;
@@ -1820,7 +1873,7 @@ const nativeMachoSourceFailure = (
           : {}),
       },
       {
-        operation: "inspect_macho",
+        operation,
         cause,
         cleanupPrimary: previous,
         partialObservation: observation,
@@ -1841,7 +1894,11 @@ const nativeMachoSourceFailure = (
       completionCancellation.retainPartialObservation(observation);
     return completionCancellation;
   }
-  return nativeMachoSourcePrimary(artifactFilePrimaryFacts(cause), target.path);
+  return nativeMachoSourcePrimary(
+    artifactFilePrimaryFacts(cause),
+    target.path,
+    operation,
+  );
 };
 
 interface NativeObservation {

src/native/NativeMacOSProviderInput.test.ts

@@ -170,3 +170,47 @@ it("declares the temporary private operand write in inspect_macho provider capab
     )?.effects,
   ).toMatchObject({ mayWriteFilesystem: true, mutatesArtifact: false });
 });
+
+it.each(["before command", "during command"] as const)(
+  "rejects architecture facts when the admitted target changes %s",
+  async (phase) => {
+    const root = await createTestTempDirectory("rea-lipo-target-identity-");
+    const path = join(root, "fixture.macho");
+    const original = inspectionImage();
+    await writeFile(path, original);
+    const target = await nativeMachoTargetForFile(path);
+    const runner = new NativeFixtureRunner({
+      lipo: `Non-fat file: ${path} is architecture: arm64\n`,
+    });
+    const run = runner.run.bind(runner);
+    const capture = vi
+      .spyOn(runner, "run")
+      .mockImplementation(async (...args) => {
+        if (phase === "during command")
+          await writeFile(
+            path,
+            Buffer.concat([original, Buffer.from("changed")]),
+          );
+        return run(...args);
+      });
+    const client = new NativeMacOSProvider({}, runner, "darwin").createClient(
+      target,
+    );
+    try {
+      if (phase === "before command")
+        await writeFile(
+          path,
+          Buffer.concat([original, Buffer.from("changed")]),
+        );
+      const result = await client.execute("list_architectures", {});
+      if (result.ok) throw new Error("Expected target identity refusal");
+      expect(result.error).toMatchObject({
+        _tag: "AnalysisArtifactChangedError",
+        operation: "list_architectures",
+      });
+      expect(capture).toHaveBeenCalledTimes(phase === "before command" ? 0 : 1);
+    } finally {
+      await client.close();
+    }
+  },
+);

src/native/NativeMacOSProviderMetadata.ts

@@ -9,12 +9,12 @@ export const APPLE_DISPATCH_METADATA_ANALYSIS_PROFILE = createAnalysisProfile(
   {
     id: NATIVE_MACOS_PROVIDER_IDENTITY.id,
     name: NATIVE_MACOS_PROVIDER_IDENTITY.name,
-    version: "apple-metadata-reader-3",
+    version: "apple-metadata-reader-4",
   },
   {
     operation: "inspect_native_dispatch_metadata",
     reader: "apple-dispatch-metadata",
-    revision: 3,
+    revision: 4,
   },
 );
 /** Operations whose target process can show UI, use the network and write files. */

src/native/NativeMachoCommandDiagnostics.test.ts

@@ -0,0 +1,34 @@
+import { expect, it } from "vitest";
+import type { NativeCommandCapture } from "./CommandRunner.js";
+import { parseDyldFileTypeRefusal } from "./NativeMachoCommandDiagnostics.js";
+
+const capture = (stdout: string, stderr = ""): NativeCommandCapture => ({
+  tool: "dyld_info",
+  executable: "/usr/bin/dyld_info",
+  executableSha256: "a".repeat(64),
+  toolVersion: null,
+  versionReason: null,
+  arguments: ["-imports", "/selected/target"],
+  stdout,
+  stderr,
+  stdoutBytes: Buffer.byteLength(stdout),
+  stderrBytes: Buffer.byteLength(stderr),
+  exitCode: 1,
+  signal: null,
+});
+
+it.each([
+  ["unknown filetype 3", "3"],
+  ["unknown mh.filetype 4", "4"],
+])("recognizes a sole dyld file-type refusal (%s)", (diagnostic, fileType) => {
+  expect(
+    parseDyldFileTypeRefusal(capture(`/selected/target:\n${diagnostic}\n`)),
+  ).toEqual({ fileType, diagnostic });
+});
+
+it.each([
+  ["unknown mh.filetype 4\nmalformed load command\n", ""],
+  ["unknown mh.filetype 4\n", "read failed\n"],
+])("keeps mixed dyld diagnostics unclassified (%s, %s)", (stdout, stderr) => {
+  expect(parseDyldFileTypeRefusal(capture(stdout, stderr))).toBeNull();
+});

src/native/NativeMachoCommandDiagnostics.ts

@@ -91,22 +91,17 @@ export const isUnbackedTextDyldFailure = (
   dyldFailureDiagnostic(capture) ===
   "section '__TEXT/__text' has offset=0 but is not a zero-fill section type";
 
-/** Reported CORE/FVMLIB refusals still require an independently matching header. */
+/** A sole CORE/FVMLIB refusal still requires an independently matching header. */
 export const parseDyldFileTypeRefusal = (
   capture: NativeCommandCapture,
 ): {
   readonly fileType: "3" | "4";
   readonly diagnostic: string;
 } | null => {
-  for (const line of dyldFailureDiagnostics(capture, [
-    capture.stdout,
-    capture.stderr,
-  ])) {
-    const fileType = /^unknown (?:mh\.)?filetype ([34])$/u.exec(line)?.[1];
-    if (fileType === "3" || fileType === "4")
-      return { fileType, diagnostic: line };
-  }
-  return null;
+  const diagnostic = dyldFailureDiagnostic(capture);
+  if (diagnostic === null) return null;
+  const fileType = /^unknown (?:mh\.)?filetype ([34])$/u.exec(diagnostic)?.[1];
+  return fileType === "3" || fileType === "4" ? { fileType, diagnostic } : null;
 };
 
 /** Complete captures come from the settled native command owner. */

src/native/NativeMachoInspection.test.ts

@@ -519,6 +519,7 @@ describe("Mach-O encryption reporting", () => {
     container_file_offset: 32768,
     size: 8192,
     status: "absent",
+    malformed_kind: null,
     reason: null,
     commands: [],
     range: null,
@@ -602,6 +603,7 @@ describe("Mach-O encryption reporting", () => {
         slice({
           container_file_offset: 49152,
           status: "malformed",
+          malformed_kind: "structure",
           reason: "load commands is truncated",
         }),
       ],

src/native/NativeMachoSourceProvider.test.ts

@@ -16,9 +16,16 @@ const control = vi.hoisted(() => ({
   read: undefined as undefined | (() => Promise<never>),
 }));
 
-it.each([false, true])(
-  "retains verified inspection evidence through close retry (late cancellation: %s)",
-  async (cancelDuringClose) => {
+it.each(
+  (["inspect_macho", "list_architectures"] as const).flatMap((operation) =>
+    [false, true].map((cancelDuringClose) => ({
+      operation,
+      cancelDuringClose,
+    })),
+  ),
+)(
+  "retains verified $operation evidence through close retry (late cancellation: $cancelDuringClose)",
+  async ({ operation, cancelDuringClose }) => {
     const root = await createTestTempDirectory("rea-macho-completed-close-");
     const path = join(root, "fixture.macho");
     await writeFile(path, inspectionImage());
@@ -60,7 +67,7 @@ it.each([false, true])(
       await client.close();
     });
     const result = await client.execute(
-      "inspect_macho",
+      operation,
       { native_command_timeout_ms: 5000 },
       { signal: controller.signal },
     );
@@ -71,7 +78,7 @@ it.each([false, true])(
     expect(result.error.cleanupIncomplete).toBe(true);
     expect(result.error.cleanupResources).toEqual([path]);
     expect(result.error.partialObservation).toMatchObject({
-      operation: "inspect_macho",
+      operation,
       parameters: { native_command_timeout_ms: 5000 },
       subject: { local_path: path, digest: { sha256: target.sha256 } },
       normalized_result: { provenance: expect.any(Array) },
@@ -108,9 +115,13 @@ it.each([false, true])(
   },
 );
 
-it.each([false, true])(
-  "retains the producer outcome when cancellation arrives during successful close (producer fails: %s)",
-  async (producerFails) => {
+it.each(
+  (["inspect_macho", "list_architectures"] as const).flatMap((operation) =>
+    [false, true].map((producerFails) => ({ operation, producerFails })),
+  ),
+)(
+  "retains the $operation producer outcome when cancellation arrives during successful close (producer fails: $producerFails)",
+  async ({ operation, producerFails }) => {
     const root = await createTestTempDirectory("rea-macho-cancel-close-");
     const path = join(root, "fixture.macho");
     await writeFile(path, inspectionImage());
@@ -148,7 +159,7 @@ it.each([false, true])(
       await client.close();
     });
     const result = await client.execute(
-      "inspect_macho",
+      operation,
       {},
       { signal: controller.signal },
     );
@@ -174,7 +185,7 @@ it.each([false, true])(
       });
     } else {
       expect(result.error.partialObservation).toMatchObject({
-        operation: "inspect_macho",
+        operation,
         subject: { local_path: path, digest: { sha256: target.sha256 } },
         normalized_result: { provenance: expect.any(Array) },
       });

src/native/apple/AppleIpsProvider.test.ts

@@ -0,0 +1,62 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { expect, it, vi } from "vitest";
+
+import * as machoReader from "../../artifacts/apple/MachoLoadCommandReader.js";
+import { inspectAppleIpsInputSchema } from "../../domain/native/appleIps.js";
+import { createTestTempDirectory } from "../../../tests/fixtures/temporaryDirectory.js";
+import { appleIpsBytes } from "../../../tests/fixtures/binaryDiagnostics/appleIps.js";
+import { AppleIpsProvider } from "./AppleIpsProvider.js";
+
+it("retains completed join facts when cancellation arrives during join parsing", async () => {
+  const root = await createTestTempDirectory("rea-ips-join-cancel-");
+  const path = join(root, "report.ips");
+  const joinPath = join(root, "image.bin");
+  await writeFile(path, appleIpsBytes());
+  const image = Buffer.alloc(32);
+  image.writeUInt32LE(0xfeedfacf, 0);
+  image.writeUInt32LE(0x0100000c, 4);
+  image.writeUInt32LE(2, 12);
+  await writeFile(joinPath, image);
+  const input = inspectAppleIpsInputSchema.parse({ path, join_path: joinPath });
+  const provider = new AppleIpsProvider();
+  const controller = new AbortController();
+  const reason = new Error("cancel while joining selected image");
+  const readContainer = machoReader.readMachoContainer;
+  const spy = vi
+    .spyOn(machoReader, "readMachoContainer")
+    .mockImplementationOnce(async (...arguments_) => {
+      const container = await readContainer(...arguments_);
+      controller.abort(reason);
+      return container;
+    });
+  try {
+    const cancelled = await provider.inspect(input, {
+      signal: controller.signal,
+    });
+    if (cancelled.ok) throw new Error("Expected cancellation during join");
+    expect(cancelled.error.cause).toBe(reason);
+    expect(cancelled.error).toMatchObject({
+      _tag: "AnalysisCancelledError",
+      cause: reason,
+      partialObservation: {
+        artifact: { path },
+        join: {
+          status: "selected",
+          path: joinPath,
+          slices: [{ arch: "arm64" }],
+        },
+        join_artifact: { path: joinPath },
+      },
+    });
+    const recovered = await provider.inspect(input);
+    if (!recovered.ok) throw recovered.error;
+    expect(recovered.value.join).toMatchObject({
+      status: "selected",
+      path: joinPath,
+    });
+  } finally {
+    spy.mockRestore();
+    await provider.close();
+  }
+});

src/native/apple/AppleIpsProvider.ts

@@ -112,7 +112,7 @@ export class AppleIpsProvider implements AppleIpsPort {
         );
         completedSnapshot = joinArtifact;
         assertArtifactReadActive(options?.signal);
-        return ok({
+        completedReport = {
           ...report,
           join: await resolveAppleIpsJoin(
             report,
@@ -123,7 +123,9 @@ export class AppleIpsProvider implements AppleIpsPort {
             },
             read,
           ),
-        });
+        };
+        assertArtifactReadActive(options?.signal);
+        return ok(completedReport);
       });
     } catch (cause) {
       const primary = appleIpsFailurePrimary(

src/native/hardening/BinaryHardeningParsers.test.ts

@@ -1186,6 +1186,20 @@ it("keeps header rows when a slice has conflicting encryption commands", async (
   });
 });
 
+it("keeps a later malformed encryption command distinct from duplicate ambiguity", async () => {
+  const bytes = machoHardeningFixture({
+    extraCommands: [
+      machoCommand(LC_ENCRYPTION_INFO_64, 24),
+      machoCommand(LC_ENCRYPTION_INFO_64, 24),
+      machoCommand(LC_ENCRYPTION_INFO_64, 8),
+    ],
+  });
+  await expect(readMachoHardening(bytes)).rejects.toMatchObject({
+    kind: "malformed",
+    message: expect.stringContaining("cmdsize 8"),
+  });
+});
+
 it("keeps a parsed fat slice when another slice is empty or past EOF", async () => {
   const arm = machoHardeningFixture();
   const images = await readMachoHardening(
@@ -1414,6 +1428,32 @@ it("sizes an empty DT_GNU_HASH table only from an agreeing SHT_DYNSYM", () => {
     });
 });
 
+it.each([32, 64] as const)(
+  "does not interpret %i-bit Mach-O debug symbol type bits as an import",
+  async (bits) => {
+    const bytes = machoHardeningFixture({ bits, stackChk: true });
+    let commandAt = bits === 64 ? 32 : 28;
+    let symbolAt: number | undefined;
+    for (let index = 0; index < bytes.readUInt32LE(16); index += 1) {
+      if (bytes.readUInt32LE(commandAt) === 2)
+        symbolAt = bytes.readUInt32LE(commandAt + 8);
+      commandAt += bytes.readUInt32LE(commandAt + 4);
+    }
+    if (symbolAt === undefined) throw new Error("Missing LC_SYMTAB");
+    expect(
+      findRow(
+        (await readMachoHardening(bytes))[0]?.rows ?? [],
+        "stack_protector",
+      ).state,
+    ).toBe("enabled");
+    // N_STAB takes precedence over ordinary N_TYPE and N_EXT interpretation.
+    bytes.writeUInt8(0x21, symbolAt + 4);
+    const image = (await readMachoHardening(bytes))[0];
+    expect(findRow(image?.rows ?? [], "stack_protector").state).toBe("unknown");
+    expect(findRow(image?.rows ?? [], "pie").state).toBe("enabled");
+  },
+);
+
 it("keeps an unresolved symbol count distinct from an absent table", () => {
   const image = readElfHardening(
     withEmptyGnuHash(elfHardeningFixture({ sections: false, stackChk: true })),

src/native/hardening/MachoHardening.ts

@@ -343,7 +343,10 @@ const readCommandFacts = (
  * wrong width, is structural and fails the slice before any row exists.
  */
 const admitEncryption = (encrypted: MachoSliceEncryption): void => {
-  if (encrypted.status === "malformed" && encrypted.commands.length < 2)
+  if (
+    encrypted.status === "malformed" &&
+    encrypted.malformed_kind !== "duplicate-commands"
+  )
     malformed(
       encrypted.reason ?? "Mach-O encryption load command is malformed",
     );
@@ -595,10 +598,11 @@ const stackRow = (
     const entry = symbolAt + index * width;
     const nameOffset = bytes.readUInt32LE(entry);
     if (nameOffset === 0) continue;
-    // N_EXT with N_TYPE clear is an undefined external. A defined export of
-    // the same name, including libc itself, is not an import into this image.
+    // N_STAB records use a different type namespace. Only an ordinary N_EXT
+    // with N_TYPE clear is an undefined external; defined exports are not imports.
     const nType = bytes.readUInt8(entry + 4);
-    if ((nType & 0x0e) !== 0 || (nType & 0x01) === 0) continue;
+    if ((nType & 0xe0) !== 0 || (nType & 0x0e) !== 0 || (nType & 0x01) === 0)
+      continue;
     // A common definition shares those type bits but carries its size in
     // n_value, so only a zero n_value names an import.
     if (

src/server/environment/StateResponseCleanup.ts

@@ -0,0 +1,53 @@
+import {
+  ArtifactResourceScope,
+  type ArtifactResourceOwner,
+} from "../../artifacts/ArtifactResourceScope.js";
+
+/** Retain a cancelled response branch until its underlying cancellation settles. */
+export class StateResponseCleanup {
+  readonly #scope = new ArtifactResourceScope();
+
+  constructor(private readonly changed: () => void = () => {}) {}
+
+  get cleanupResources(): readonly string[] {
+    return this.#scope.cleanupResources;
+  }
+
+  cancel(cancel: () => Promise<void>): void {
+    let state:
+      | { status: "pending" }
+      | { status: "done" }
+      | { status: "failed"; cause: unknown } = { status: "pending" };
+    const owner: ArtifactResourceOwner = {
+      kind: "lease",
+      resource: "state response body",
+      lease: {
+        release: async () => {
+          if (state.status === "pending")
+            throw new Error("State response cancellation is still pending");
+          if (state.status === "failed") throw state.cause;
+        },
+      },
+    };
+    this.#scope.retain(owner);
+    this.changed();
+    void Promise.resolve()
+      .then(cancel)
+      .then(
+        async () => {
+          state = { status: "done" };
+          await this.#scope.release(owner);
+          this.changed();
+        },
+        (cause: unknown) => {
+          state = { status: "failed", cause };
+          this.changed();
+        },
+      )
+      .catch(() => undefined);
+  }
+
+  close(): Promise<void> {
+    return this.#scope.close();
+  }
+}

src/server/environment/environmentDataPlane.ts

@@ -1,3 +1,4 @@
+import { StateResponseCleanup } from "./StateResponseCleanup.js";
 import type { EnvironmentStateStore } from "../../application/environment/environmentStateStore.js";
 import { ArtifactResourceScope } from "../../artifacts/ArtifactResourceScope.js";
 import type { AnalysisInputError } from "../../domain/analysisErrorCore.js";
@@ -46,17 +47,24 @@ interface CallContext {
   readonly intake: StateIntake;
   readonly cancel: AbortSignal;
   readonly files: ArtifactResourceScope;
+  readonly responses: StateResponseCleanup;
 }
 
 /** `data/add`: exactly one part, whose document replaces the whole state only when it is valid and the call was not cancelled. */
 const addState = async (
-  { store, intake, cancel, files }: CallContext,
+  { store, intake, cancel, files, responses }: CallContext,
   params: unknown,
 ): Promise<RpcOutcome> => {
   const parts = isRecord(params) ? params.parts : undefined;
   if (!Array.isArray(parts) || parts.length !== 1)
     return { error: invalidParams("data/add takes exactly one part") };
-  const document = await partDocument(parts[0], intake, cancel, files);
+  const document = await partDocument(
+    parts[0],
+    intake,
+    cancel,
+    files,
+    responses,
+  );
   if (!document.ok) return { error: document.error };
   // A file read is not interruptible, so a cancellation during it is honoured here, before the state changes.
   if (cancel.aborted) return { error: CANCELLED };
@@ -101,6 +109,7 @@ export const stateDataPlane = (
   intake: StateIntake = DEFAULT_STATE_INTAKE,
   stopped: AbortSignal = new AbortController().signal,
   files: ArtifactResourceScope = new ArtifactResourceScope(),
+  responses: StateResponseCleanup = new StateResponseCleanup(),
 ): RpcMethods => {
   let previous: Promise<unknown> = Promise.resolve();
   return (method, params, signal) => {
@@ -111,7 +120,7 @@ export const stateDataPlane = (
     const next = previous.then(() =>
       cancel.aborted
         ? { error: CANCELLED }
-        : run({ store, intake, cancel, files }, params),
+        : run({ store, intake, cancel, files, responses }, params),
     );
     previous = next.catch(() => undefined);
     return next;

src/server/environment/serveEnvironment.ts

@@ -1,3 +1,4 @@
+import { StateResponseCleanup } from "./StateResponseCleanup.js";
 import type { HttpHostname } from "../../domain/httpHostname.js";
 import { STATE_INTAKE_LIMIT_BYTES } from "../../application/environment/environmentStateDocument.js";
 import {
@@ -477,6 +478,8 @@ export const serveEnvironment = async (
   };
   // A state file whose close failed stays owned here: later file reads retry it, and close reports it if it is still open.
   const stateFiles = new ArtifactResourceScope();
+  let responseStateChanged = (): void => undefined;
+  const stateResponses = new StateResponseCleanup(() => responseStateChanged());
   const served = await serveStreamableHttp({
     host,
     port,
@@ -499,6 +502,7 @@ export const serveEnvironment = async (
             },
             stopping.signal,
             stateFiles,
+            stateResponses,
           ),
     ),
     ...(logger === undefined ? {} : { logger }),
@@ -512,11 +516,14 @@ export const serveEnvironment = async (
   });
   let httpClosePending = false;
   let stateClosePending = false;
+  let responseClosePending = false;
+  let settledSuccessful = false;
   let closing: Promise<void> | undefined;
   const shutdownFailures = new Set<AnalysisError>();
   const owner: EnvironmentShutdownOwner = {
     get cleanupResources() {
       const stateResources = stateFiles.cleanupResources;
+      const responseResources = stateResponses.cleanupResources;
       return [
         ...(httpClosePending ? [served.url] : []),
         ...(stateClosePending
@@ -524,6 +531,11 @@ export const serveEnvironment = async (
             ? stateResources
             : ["environment state-file scope"]
           : []),
+        ...(responseClosePending
+          ? responseResources.length > 0
+            ? responseResources
+            : ["state response cleanup"]
+          : []),
       ];
     },
     close: () => {
@@ -531,7 +543,7 @@ export const serveEnvironment = async (
       const attempt = (async () => {
         stop();
         const failures: {
-          readonly stage: "http-server" | "state-files";
+          readonly stage: "http-server" | "state-files" | "state-responses";
           readonly cause: unknown;
         }[] = [];
         try {
@@ -548,6 +560,15 @@ export const serveEnvironment = async (
           stateClosePending = true;
           failures.push({ stage: "state-files", cause });
         }
+        try {
+          await stateResponses.close();
+          if (stateResponses.cleanupResources.length > 0)
+            throw new Error("State response cleanup remains pending");
+          responseClosePending = false;
+        } catch (cause: unknown) {
+          responseClosePending = true;
+          failures.push({ stage: "state-responses", cause });
+        }
         if (failures.length > 0) {
           retainedEnvironmentShutdowns.add(owner);
           const failure = new AnalysisOutputError(
@@ -583,6 +604,7 @@ export const serveEnvironment = async (
         retainedEnvironmentShutdowns.delete(owner);
         for (const failure of shutdownFailures) failure.resolveCleanup();
         shutdownFailures.clear();
+        settledSuccessful = true;
       })();
       closing = attempt;
       void attempt.catch(() => {
@@ -591,6 +613,26 @@ export const serveEnvironment = async (
       return attempt;
     },
   };
+  // A fetcher may hand back a response after an earlier stop completed. Keep
+  // that newly acquired body owned and make a later close observe its outcome.
+  responseStateChanged = () => {
+    if (!stopping.signal.aborted) return;
+    if (stateResponses.cleanupResources.length > 0) {
+      responseClosePending = true;
+      retainedEnvironmentShutdowns.add(owner);
+      if (settledSuccessful) {
+        settledSuccessful = false;
+        closing = undefined;
+      }
+    } else if (
+      shutdownFailures.size === 0 &&
+      !httpClosePending &&
+      !stateClosePending
+    ) {
+      responseClosePending = false;
+      retainedEnvironmentShutdowns.delete(owner);
+    }
+  };
   return ok({
     ...served,
     card,

src/server/environment/serveEnvironmentState.test.ts

@@ -1037,7 +1037,122 @@ describe("serveEnvironment with a state", () => {
       expect(missing.isError).toBe(true);
     });
   });
+});
 
+describe("state response cleanup", () => {
+  it("reports pending teed response cleanup and retries after its sibling closes", async () => {
+    let sourceCancelled = false;
+    const stream = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(new Uint8Array([1]));
+      },
+      cancel() {
+        sourceCancelled = true;
+      },
+    });
+    const [body, sibling] = stream.tee();
+    const environment = await serveState(
+      { source, state },
+      {
+        fetchState: async () =>
+          new Response(body, {
+            headers: { "content-length": String(STATE_INTAKE_LIMIT_BYTES + 1) },
+          }),
+      },
+    );
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      const response = await fetch(
+        new URL(ENVIRONMENT_RPC_PATH, environment.url),
+        {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify(addByUri(1)),
+          signal: AbortSignal.timeout(10_000),
+        },
+      );
+      await expect(response.json()).resolves.toMatchObject({
+        error: { code: -32602 },
+      });
+      const closing = Promise.race([
+        environment.close(),
+        new Promise<never>((_, reject) => {
+          timer = setTimeout(
+            () => reject(new Error("server close waited for tee sibling")),
+            10_000,
+          );
+        }),
+      ]);
+      await expect(closing).rejects.toMatchObject({
+        _tag: "AnalysisOutputError",
+        cleanupIncomplete: true,
+        diagnostics: { cleanup_stages: ["state-responses"] },
+      });
+      expect(sourceCancelled).toBe(false);
+      await sibling.cancel();
+      expect(sourceCancelled).toBe(true);
+      await expect(environment.close()).resolves.toBeUndefined();
+    } finally {
+      if (timer !== undefined) clearTimeout(timer);
+      await Promise.allSettled([body.cancel(), sibling.cancel()]);
+      await environment.close();
+    }
+  });
+
+  it("retains a late response cleanup after an earlier successful stop", async () => {
+    let giveResponse!: (response: Response) => void;
+    const gate = new Promise<Response>((resolve) => {
+      giveResponse = resolve;
+    });
+    const held = heldFetcher(() => gate);
+    let release!: () => void;
+    let acknowledge!: () => void;
+    const cleanup = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    const entered = new Promise<void>((resolve) => {
+      acknowledge = resolve;
+    });
+    const environment = await serveState(
+      { source, state },
+      { fetchState: held.fetchState },
+    );
+    const answered = fetch(new URL(ENVIRONMENT_RPC_PATH, environment.url), {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(addByUri(1)),
+      signal: AbortSignal.timeout(10_000),
+    }).catch(() => undefined);
+    try {
+      await held.fetching;
+      await environment.close();
+      giveResponse(
+        new Response(
+          new ReadableStream<Uint8Array>({
+            cancel() {
+              acknowledge();
+              return cleanup;
+            },
+          }),
+        ),
+      );
+      await entered;
+      await expect(environment.close()).rejects.toMatchObject({
+        _tag: "AnalysisOutputError",
+        cleanupIncomplete: true,
+        diagnostics: { cleanup_stages: ["state-responses"] },
+      });
+      release();
+      await expect(environment.close()).resolves.toBeUndefined();
+    } finally {
+      release();
+      await answered;
+      await environment.close();
+    }
+  });
+});
+
+describe("serveEnvironment state file cleanup", () => {
   it("stops without waiting for a stalled download", async () => {
     const held = heldFetcher(() => new Promise<Response>(() => undefined));
     const environment = await serveState(

src/server/environment/stateIntake.test.ts

@@ -1,3 +1,4 @@
+import { StateResponseCleanup } from "./StateResponseCleanup.js";
 import { expect, it, vi } from "vitest";
 
 import { ArtifactResourceScope } from "../../artifacts/ArtifactResourceScope.js";
@@ -11,14 +12,17 @@ import {
 
 const inlineDocument = async (bytes: string) => {
   const files = new ArtifactResourceScope();
+  const responses = new StateResponseCleanup();
   try {
     return await partDocument(
       { kind: "file", file: { bytes } },
       DEFAULT_STATE_INTAKE,
       new AbortController().signal,
       files,
+      responses,
     );
   } finally {
+    await responses.close();
     await files.close();
   }
 };
@@ -79,3 +83,109 @@ it("downloads with redirects refused and the 30 s timeout by default", async ()
     fetched.mockRestore();
   }
 });
+
+it.each(["http-status", "declared-overflow", "stream-overflow"] as const)(
+  "returns %s while a teed response's other branch remains open",
+  async (scenario) => {
+    const source = new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(
+          new Uint8Array(
+            scenario === "stream-overflow" ? STATE_INTAKE_LIMIT_BYTES + 1 : 1,
+          ),
+        );
+      },
+    });
+    const [body, sibling] = source.tee();
+    const response = new Response(body, {
+      status: scenario === "http-status" ? 503 : 200,
+      ...(scenario === "declared-overflow"
+        ? {
+            headers: { "content-length": String(STATE_INTAKE_LIMIT_BYTES + 1) },
+          }
+        : {}),
+    });
+    const files = new ArtifactResourceScope();
+    const responses = new StateResponseCleanup();
+    const operation = partDocument(
+      { kind: "file", file: { uri: "https://state.example.test/state.json" } },
+      { fetchState: async () => response, timeoutMs: 1_000 },
+      new AbortController().signal,
+      files,
+      responses,
+    );
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      const outcome = await Promise.race([
+        operation.then((result) => ({ kind: "result" as const, result })),
+        new Promise<{ kind: "deadline" }>((resolve) => {
+          timer = setTimeout(() => resolve({ kind: "deadline" }), 3_000);
+        }),
+      ]);
+      expect(outcome.kind).toBe("result");
+      expect(responses.cleanupResources).toEqual(["state response body"]);
+      await expect(responses.close()).rejects.toMatchObject({
+        reason: "unavailable",
+      });
+      if (outcome.kind === "result") {
+        expect(outcome.result).toMatchObject(
+          scenario === "http-status"
+            ? { ok: false, error: { data: { reason: "http-status" } } }
+            : {
+                ok: false,
+                error: {
+                  message: expect.stringContaining(
+                    String(STATE_INTAKE_LIMIT_BYTES),
+                  ),
+                },
+              },
+        );
+      }
+    } finally {
+      if (timer !== undefined) clearTimeout(timer);
+      await sibling.cancel();
+      await operation;
+      await responses.close();
+      await files.close();
+    }
+  },
+);
+
+it("retains the exact failure when response cancellation rejects", async () => {
+  const failure = new Error("controlled cancellation failure");
+  const body = new ReadableStream<Uint8Array>({
+    cancel() {
+      throw failure;
+    },
+  });
+  const files = new ArtifactResourceScope();
+  const responses = new StateResponseCleanup();
+  const result = await partDocument(
+    { kind: "file", file: { uri: "https://state.example.test/state.json" } },
+    {
+      fetchState: async () => new Response(body, { status: 503 }),
+      timeoutMs: 1_000,
+    },
+    new AbortController().signal,
+    files,
+    responses,
+  );
+  expect(result).toMatchObject({
+    ok: false,
+    error: { data: { reason: "http-status" } },
+  });
+  await new Promise<void>((resolve) => setImmediate(resolve));
+  const rejected: unknown = await responses
+    .close()
+    .catch((cause: unknown) => cause);
+  expect(rejected).toMatchObject({
+    reason: "unavailable",
+    cleanup: { resources: ["state response body"] },
+  });
+  expect((rejected as Error).cause).toBeInstanceOf(AggregateError);
+  expect(((rejected as Error).cause as AggregateError).errors).toContain(
+    failure,
+  );
+  expect(responses.cleanupResources).toEqual(["state response body"]);
+  await files.close();
+});

src/server/environment/stateIntake.ts

@@ -1,3 +1,4 @@
+import { StateResponseCleanup } from "./StateResponseCleanup.js";
 import { fileURLToPath } from "node:url";
 
 import { mediaTypeEssence } from "../../domain/analysisView/recordedMediaType.js";
@@ -228,6 +229,7 @@ const downloadBounds = (
 const readCapped = async (
   body: ReadableStream<Uint8Array> | null,
   bounds: DownloadBounds,
+  responses: StateResponseCleanup,
 ): Promise<Result<Buffer, RpcError>> => {
   if (body === null) return ok(Buffer.alloc(0));
   const reader = body.getReader();
@@ -240,13 +242,15 @@ const readCapped = async (
       if (done) return ok(Buffer.concat(chunks, total));
       total += value.byteLength;
       if (total > STATE_INTAKE_LIMIT_BYTES) {
-        await reader.cancel().catch(() => undefined);
+        // A tee's sibling can be caller-owned; cancelling this branch must not
+        // delay the refusal until that sibling finishes.
+        responses.cancel(() => reader.cancel());
         return err(TOO_LARGE);
       }
       chunks.push(value);
     }
   } catch {
-    void reader.cancel().catch(() => undefined);
+    responses.cancel(() => reader.cancel());
     return err(fetchFailed(bounds.failure()));
   }
 };
@@ -256,6 +260,7 @@ const downloadState = async (
   url: URL,
   intake: StateIntake,
   cancel: AbortSignal,
+  responses: StateResponseCleanup,
 ): Promise<Result<Buffer, RpcError>> => {
   const bounds = downloadBounds(intake.timeoutMs, cancel);
   const fetching = Promise.resolve().then(() =>
@@ -268,7 +273,9 @@ const downloadState = async (
     // A response that arrives after the download ended is released unread.
     void fetching
       .then(
-        (late) => late.body?.cancel(),
+        (late) => {
+          if (late.body !== null) responses.cancel(() => late.body!.cancel());
+        },
         () => undefined,
       )
       .catch(() => undefined);
@@ -276,7 +283,8 @@ const downloadState = async (
   }
   const declared = Number(response.headers.get("content-length") ?? "0");
   if (!response.ok || declared > STATE_INTAKE_LIMIT_BYTES) {
-    await response.body?.cancel().catch(() => undefined);
+    // Cancel this branch without waiting for a potentially independent tee sibling.
+    if (response.body !== null) responses.cancel(() => response.body!.cancel());
     return err(
       response.ok
         ? TOO_LARGE
@@ -286,7 +294,7 @@ const downloadState = async (
           },
     );
   }
-  return readCapped(response.body, bounds);
+  return readCapped(response.body, bounds, responses);
 };
 
 const NETWORK_SHARE = invalidParams(
@@ -315,6 +323,7 @@ const fileBytes = async (
   intake: StateIntake,
   cancel: AbortSignal,
   files: ArtifactResourceScope,
+  responses: StateResponseCleanup,
 ): Promise<Result<Uint8Array, RpcError>> => {
   if (typeof file.bytes === "string" && file.uri === undefined) {
     if (file.bytes.length > MAX_INLINE_BASE64_CHARACTERS) return err(TOO_LARGE);
@@ -333,7 +342,8 @@ const fileBytes = async (
       invalidParams("a file part carries exactly one of bytes or a uri"),
     );
   const url = new URL(file.uri);
-  if (url.protocol === "https:") return downloadState(url, intake, cancel);
+  if (url.protocol === "https:")
+    return downloadState(url, intake, cancel, responses);
   if (url.protocol !== "file:")
     return err(invalidParams("a file uri is a file:// or https:// URL"));
   const path = localFilePath(url);
@@ -346,6 +356,7 @@ export const partDocument = async (
   intake: StateIntake,
   cancel: AbortSignal,
   files: ArtifactResourceScope,
+  responses: StateResponseCleanup,
 ): Promise<Result<unknown, RpcError>> => {
   if (isRecord(part) && part.kind === "data" && isRecord(part.data))
     return ok(part.data);
@@ -362,6 +373,6 @@ export const partDocument = async (
       mediaTypeEssence(mimeType) !== "application/json")
   )
     return err(invalidParams("a file part's mimeType is application/json"));
-  const bytes = await fileBytes(part.file, intake, cancel, files);
+  const bytes = await fileBytes(part.file, intake, cancel, files, responses);
   return bytes.ok ? parseDocumentBytes(bytes.value) : bytes;
 };

tests/acceptance/applications/javascriptChildProcessStdioCli.test.ts

@@ -15,6 +15,13 @@ const cases = [
     0,
   ],
   ['spawn("control", [], {stdio:"inherit"})', "control", "inherit", 0],
+  ['spawn("global-nan-env", [], {env:NaN})', "global-nan-env", "default", 0],
+  [
+    '((NaN) => spawn("shadowed-nan-env", [], {env:NaN}))({})',
+    "shadowed-nan-env",
+    "default",
+    0,
+  ],
   [
     'spawn("spread-after", [], {stdio:"pipe",...input})',
     "spread-after",
@@ -233,6 +240,12 @@ const exportAssignmentSource = `
   export = argv;
 `;
 
+const environmentCommands = [
+  "named-argv",
+  "execfile-dynamic",
+  "shadowed-nan-env",
+];
+
 // Callback/options ambiguity cannot change exec's effective stdio.
 const opaqueExecCallbackCommands = [
   "eval-callback",
@@ -342,7 +355,7 @@ cliTest.for(["CLI", "stdio MCP"] as const)(
       expect(child.properties.stdio_mode, String(command)).toBe(mode);
       expect(child.properties.argv_count, String(command)).toBe(count);
       expect(child.properties.environment_supplied, String(command)).toBe(
-        ["named-argv", "execfile-dynamic"].includes(String(command)),
+        environmentCommands.includes(String(command)),
       );
       expect(child.identity.source_range).not.toBeNull();
       const stdio = graph.relations.filter(
@@ -377,9 +390,7 @@ cliTest.for(["CLI", "stdio MCP"] as const)(
             relation.relation === "supplies-env" &&
             relation.target_node_id === child.node_id,
         ),
-      ).toHaveLength(
-        ["named-argv", "execfile-dynamic"].includes(String(command)) ? 1 : 0,
-      );
+      ).toHaveLength(environmentCommands.includes(String(command)) ? 1 : 0);
       expect(
         graph.relations.filter(
           (relation) =>

tests/boundary/cli/cutterVerifierPlatform.test.ts

@@ -1,81 +1,72 @@
-import { execFile } from "node:child_process";
-import { readFile, readdir, writeFile } from "node:fs/promises";
+import { readFile, readdir } from "node:fs/promises";
 import { join } from "node:path";
-import { promisify } from "node:util";
-import { expect, it } from "vitest";
+import { expect } from "vitest";
 import { parse } from "yaml";
+import { resolveSwiftcCompileTimeoutMs } from "../../../src/process/DarwinProcessRunTokenReader.js";
 import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
+import { processTest } from "../../support/process/processFixture.js";
 
-const execute = promisify(execFile);
+const hostLabels: Partial<Record<NodeJS.Platform, string>> = {
+  linux: "linux",
+  darwin: "macOS",
+  win32: "Windows",
+};
+const hostLabel = hostLabels[process.platform];
+const preparationBudget =
+  process.platform === "darwin" ? resolveSwiftcCompileTimeoutMs() : 0;
 
-it("enforces workflow platform labels before contacting Cutter", async () => {
-  const workflow = parse(
-    await readFile(".github/workflows/real-cutter.yml", "utf8"),
-  );
-  const labels = workflow.jobs["cutter-upstream"].strategy.matrix.include.map(
-    (entry: { platform: string }) => entry.platform,
-  );
-  expect(labels).toEqual(["linux", "macOS", "Windows"]);
-  const root = await createTestTempDirectory("rea-cutter-platform-");
-  const preload = join(root, "preload.mjs");
-  await writeFile(
-    preload,
-    `
-import childProcess from 'node:child_process';
-import { syncBuiltinESMExports } from 'node:module';
-Object.defineProperty(process, 'platform', { value: process.env.REA_PROBE_PLATFORM });
-childProcess.execFile = () => { throw new Error('fixture discovery reached'); };
-syncBuiltinESMExports();
-`,
-  );
-  const check = async (selected: string | undefined, actual: string) => {
-    const env: NodeJS.ProcessEnv = {
-      ...process.env,
-      TMPDIR: root,
-      TMP: root,
-      TEMP: root,
-      REA_PROBE_PLATFORM: actual,
+processTest.skipIf(hostLabel === undefined)(
+  "enforces workflow platform labels before contacting Cutter",
+  { timeout: Math.min(2_147_483_647, 2 * preparationBudget + 30_000) },
+  async ({ processes }) => {
+    const workflow = parse(
+      await readFile(".github/workflows/real-cutter.yml", "utf8"),
+    );
+    const labels = workflow.jobs["cutter-upstream"].strategy.matrix.include.map(
+      (entry: { platform: string }) => entry.platform,
+    );
+    expect(labels).toEqual(["linux", "macOS", "Windows"]);
+    const root = await createTestTempDirectory("rea-cutter-platform-");
+    // A private absent directory proves actual discovery without contacting a user's bridge.
+    const bridgeDirectory = join(root, "absent-bridge");
+    const check = async (selected: string | undefined) => {
+      const env: NodeJS.ProcessEnv = {
+        ...process.env,
+        TMPDIR: root,
+        TMP: root,
+        TEMP: root,
+        REA_CUTTER_BRIDGE_DIR: bridgeDirectory,
+      };
+      if (selected === undefined) delete env.EXPECTED_PLATFORM;
+      else env.EXPECTED_PLATFORM = selected;
+      const result = await processes.run(
+        process.execPath,
+        ["scripts/verify-real-cutter.mjs"],
+        {
+          env,
+          timeoutMs: Math.min(2_147_483_647, preparationBudget + 15_000),
+        },
+      );
+      expect(result.exitCode, result.stderr).toBe(1);
+      return result.stderr;
     };
-    if (selected === undefined) delete env.EXPECTED_PLATFORM;
-    else env.EXPECTED_PLATFORM = selected;
-    const result: unknown = await execute(
-      process.execPath,
-      ["--import", preload, "scripts/verify-real-cutter.mjs"],
-      { env, timeout: 10_000 },
-    ).then(
-      () => {
-        throw new Error("Fixture discovery should stop the verifier");
-      },
-      (error: unknown) => error,
+    for (const selected of [hostLabel, undefined]) {
+      const stderr = await check(selected);
+      expect(stderr).toContain("Open upstream Cutter with the REA plugin");
+      expect(stderr).toContain("no_live_bridge_found");
+    }
+    const other = labels.find((label: string) => label !== hostLabel);
+    expect(other).toBeDefined();
+    expect(await check(other)).toContain(
+      "Cutter runner did not match its declared platform",
     );
-    if (
-      !(result instanceof Error) ||
-      !("stderr" in result) ||
-      typeof result.stderr !== "string"
-    )
-      throw new Error("Missing verifier diagnostics");
-    return result.stderr;
-  };
-  for (const [selected, actual] of [
-    ["linux", "linux"],
-    ["macOS", "darwin"],
-    ["Windows", "win32"],
-  ] as const)
-    expect(await check(selected, actual)).toContain(
-      "fixture discovery reached",
+    expect(await check("unknown")).toContain(
+      "Unrecognized Cutter runner platform",
     );
-  expect(await check("linux", "darwin")).toContain(
-    "Cutter runner did not match its declared platform",
-  );
-  expect(await check("unknown", "linux")).toContain(
-    "Unrecognized Cutter runner platform",
-  );
-  expect(await check(undefined, "linux")).toContain(
-    "fixture discovery reached",
-  );
-  expect(
-    (await readdir(root)).filter((name) =>
-      name.startsWith("rea-cutter-smoke-"),
-    ),
-  ).toEqual([]);
-});
+    expect(
+      (await readdir(root)).filter((name) =>
+        name.startsWith("rea-cutter-smoke-"),
+      ),
+    ).toEqual([]);
+  },
+);

tests/boundary/filesystem/ciChangeScope.test.ts

@@ -783,7 +783,7 @@ it.each([
     { code: false, ghidra_bridge: true, runtime: false, package: false },
   ],
   [
-    "tests/conformance/ghidra/ReaArmContextProbe.java",
+    "tests/conformance/ghidra/ReaInstructionContextProbe.java",
     { ghidra_bridge: true, runtime: false, package: false },
   ],
   [

tests/boundary/mcp/analysisViewMcp.test.ts

@@ -1656,6 +1656,7 @@ it("advertises Mach-O pages whose selected facet owns their exact rows", async (
         size: 4096,
         status: "absent",
         reason: null,
+        malformed_kind: null,
         commands: [],
         range: null,
       },
@@ -1663,10 +1664,21 @@ it("advertises Mach-O pages whose selected facet owns their exact rows", async (
     provenance: [],
     limitations: [],
   });
+  const { malformed_kind: _unrecorded, ...recordedEncryption } =
+    report.encryption.items[0]!;
+  const historicalEncryption = {
+    ...recordedEncryption,
+    status: "malformed" as const,
+    reason: "slice has 3 encryption load commands",
+  };
   const parent = createEvidence(
     { path: "/fixtures/tool", format: "mach-o", sha256: "a".repeat(64) },
     { id: "native", name: "Native fixture", version: "1" },
-    { operation: "inspect_macho", parameters: {}, result: report },
+    {
+      operation: "inspect_macho",
+      parameters: {},
+      result: { ...report, encryption: coverage([historicalEncryption]) },
+    },
   );
   const original = structuredClone(parent);
   expect(session.recordEvidence(parent).ok).toBe(true);
@@ -1696,7 +1708,11 @@ it("advertises Mach-O pages whose selected facet owns their exact rows", async (
       const delivered = parseEvidence(response.structuredContent);
       const page = analysisViewResultSchema.parse(delivered.normalized_result);
       if (page.kind !== "macho") throw new Error("Expected Mach-O page");
-      expect(page.item).toEqual(report[facet].items.slice(offset, offset + 64));
+      const rows =
+        facet === "encryption"
+          ? [{ ...historicalEncryption, malformed_kind: "unrecorded" }]
+          : report[facet].items;
+      expect(page.item).toEqual(rows.slice(offset, offset + 64));
       if (page.item.length > 0) {
         const mismatched = {
           ...delivered,

tests/boundary/mcp/ntfsMftAdmission.test.ts

@@ -0,0 +1,84 @@
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+
+import { expect } from "vitest";
+
+import { createBinarySession } from "../../../src/composition/binary.js";
+import { parseConfig } from "../../../src/config/parseConfig.js";
+import { artifactInspectionResultSchema } from "../../../src/domain/artifactInspection.js";
+import { parseEvidence } from "../../../src/domain/evidence.js";
+import { silentLogger } from "../../../src/logger.js";
+import { createServer } from "../../../src/server/createServer.js";
+import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
+import { mcpTest } from "../../support/mcp/mcpFixture.js";
+import { serveCli } from "../cli/cliServeHarness.js";
+
+const expectMftInventory = (value: unknown): void => {
+  const evidence = parseEvidence(value);
+  const inspection = artifactInspectionResultSchema.parse(
+    evidence.normalized_result,
+  );
+  const inventory = inspection.substeps[0]?.evidence.normalized_result;
+  expect(inventory?.manifest.root_format).toBe("ntfs-mft");
+  expect(inventory?.occurrences[0]?.format_metadata).toMatchObject({
+    kind: "ntfs-mft",
+    record_count: 1,
+    fixup_unverified_record_count: 0,
+    record_headers: [
+      {
+        index: 0,
+        fileOffset: 0,
+        sequenceNumber: 1,
+        declaredRecordNumber: null,
+        fixups: { verifiedSectors: 2 },
+      },
+    ],
+    omitted_record_headers: 0,
+  });
+};
+
+mcpTest(
+  "admits an MFT capture by signature through CLI and MCP",
+  async ({ mcp, onTestFinished }) => {
+    const root = await createTestTempDirectory("rea-ntfs-mft-admission-");
+    const path = join(root, "capture.bin");
+    const record = Buffer.alloc(1024);
+    record.write("FILE");
+    record.writeUInt16LE(42, 4);
+    record.writeUInt16LE(3, 6);
+    record.writeUInt16LE(1, 16);
+    record.writeUInt16LE(56, 20);
+    record.writeUInt32LE(64, 24);
+    record.writeUInt32LE(0xffff_ffff, 56);
+    record.writeUInt32LE(1024, 28);
+    record.writeUInt16LE(5, 42);
+    record.writeUInt16LE(5, 510);
+    record.writeUInt16LE(5, 1022);
+    await writeFile(path, record);
+
+    const cli = await serveCli(["inspect-artifact", path, "--json"]);
+    expect(cli.exitCode, cli.stdout).toBe(0);
+    expectMftInventory(JSON.parse(cli.stdout));
+
+    const configured = parseConfig({ REA_ANALYSIS_PROVIDER: "auto" });
+    if (!configured.ok) throw configured.error;
+    const session = createBinarySession(configured.value, silentLogger, {});
+    onTestFinished(async () => {
+      await session.close();
+    });
+    const client = await mcp.connect(
+      createServer({ kind: "session", session }),
+    );
+    const opened = await client.callTool({
+      name: "open_binary",
+      arguments: { path },
+    });
+    expect(opened.isError, JSON.stringify(opened.content)).not.toBe(true);
+    const inspected = await client.callTool({
+      name: "inspect_artifact",
+      arguments: {},
+    });
+    expect(inspected.isError, JSON.stringify(inspected.content)).not.toBe(true);
+    expectMftInventory(inspected.structuredContent);
+  },
+);

tests/boundary/process/agentEvaluationCommands.test.ts

@@ -1,4 +1,4 @@
-import { readFile, writeFile } from "node:fs/promises";
+import { readFile, stat, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { expect } from "vitest";
@@ -175,7 +175,11 @@ registerHooks({ load(url, context, nextLoad) {
         ),
       ],
       {
-        env: { ...process.env, REA_AGENT_EVAL_ROOT: parent },
+        env: {
+          ...process.env,
+          REA_AGENT_EVAL_ROOT: parent,
+          REA_AGENT_EVAL_KEEP_FIXTURES: "false",
+        },
         timeoutMs: 10_000,
       },
     );
@@ -190,14 +194,13 @@ registerHooks({ load(url, context, nextLoad) {
     if (incomplete) {
       expect(result.stderr).toContain("Artifact cleanup remains incomplete");
       expect(result.stderr).toContain("fixture cleanup denied");
-      expect(await readFile(join(run, "codex/auth.json"), "utf8")).toBe(
-        "inert fixture",
-      );
+      expect((await stat(run)).isDirectory()).toBe(true);
     } else {
-      await expect(
-        readFile(join(run, "codex/auth.json")),
-      ).rejects.toMatchObject({ code: "ENOENT" });
+      await expect(stat(run)).rejects.toMatchObject({ code: "ENOENT" });
     }
+    await expect(readFile(join(run, "codex/auth.json"))).rejects.toMatchObject({
+      code: "ENOENT",
+    });
   },
 );
 
@@ -274,7 +277,11 @@ registerHooks({ load(url, context, nextLoad) {
         ),
       ],
       {
-        env: { ...process.env, REA_AGENT_EVAL_ROOT: parent },
+        env: {
+          ...process.env,
+          REA_AGENT_EVAL_ROOT: parent,
+          REA_AGENT_EVAL_KEEP_FIXTURES: "false",
+        },
         timeoutMs: 10_000,
       },
     );
@@ -298,13 +305,14 @@ registerHooks({ load(url, context, nextLoad) {
     if (incomplete) {
       expect(result.stderr).toContain("Artifact cleanup remains incomplete");
       expect(result.stderr).toContain("darwin-fixture-reader");
-      expect(
-        await readFile(join(observed.run, "codex/auth.json"), "utf8"),
-      ).toBe("inert preparation fixture");
+      expect((await stat(observed.run)).isDirectory()).toBe(true);
     } else {
-      await expect(
-        readFile(join(observed.run, "codex/auth.json")),
-      ).rejects.toMatchObject({ code: "ENOENT" });
+      await expect(stat(observed.run)).rejects.toMatchObject({
+        code: "ENOENT",
+      });
     }
+    await expect(
+      readFile(join(observed.run, "codex/auth.json")),
+    ).rejects.toMatchObject({ code: "ENOENT" });
   },
 );

tests/boundary/process/releaseArtifactCanary.test.ts

@@ -1,24 +1,57 @@
-import { execFile } from "node:child_process";
 import {
   copyFile,
+  cp,
   mkdir,
   readFile,
   symlink,
   writeFile,
 } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
-import { promisify } from "node:util";
-import { expect, it } from "vitest";
+import { join, resolve } from "node:path";
+import { expect } from "vitest";
 import { z } from "zod";
 import { createApplicationMcpHarness } from "../../fixtures/applicationMcpHarness.js";
 import { createTestTempDirectory } from "../../fixtures/temporaryDirectory.js";
+import { processTest } from "../../support/process/processFixture.js";
+import { resolveSwiftcCompileTimeoutMs } from "../../../src/process/DarwinProcessRunTokenReader.js";
 
-const execute = promisify(execFile);
+const preparationBudget =
+  process.platform === "darwin" ? resolveSwiftcCompileTimeoutMs() : 0;
+
+async function prepareController(controller: string, version: string) {
+  // The verifier loads its production-owned TypeScript source graph at runtime.
+  // Keep that graph in the isolated controller so imports cannot drift from a hand-maintained list.
+  await mkdir(join(controller, "scripts"), { recursive: true });
+  await copyFile(
+    "scripts/verify-release-artifact.mjs",
+    join(controller, "scripts/verify-release-artifact.mjs"),
+  );
+  await cp("scripts/lib", join(controller, "scripts/lib"), {
+    recursive: true,
+  });
+  await mkdir(join(controller, "bridge"), { recursive: true });
+  await cp("bridge/process", join(controller, "bridge/process"), {
+    recursive: true,
+  });
+  await cp("src", join(controller, "src"), {
+    recursive: true,
+    filter: (source) => !/\.(?:test|spec)\.[cm]?[jt]sx?$/u.test(source),
+  });
+  await writeFile(
+    join(controller, "package.json"),
+    JSON.stringify({ name: "rea-agents", version, type: "module" }),
+  );
+  await symlink(
+    resolve("node_modules"),
+    join(controller, "node_modules"),
+    process.platform === "win32" ? "junction" : "dir",
+  );
+}
 
 // Release rehearsal runs on Linux; the npm process adapter is also exercised on macOS.
-it.skipIf(process.platform === "win32")(
+processTest.skipIf(process.platform === "win32")(
   "fails without declared runtime, then rehearses an installed tarball and rejects catalog drift",
-  async () => {
+  { timeout: Math.min(2_147_483_647, 3 * preparationBudget + 210_000) },
+  async ({ processes }) => {
     const root = await createTestTempDirectory("rea-release-canary-");
     const candidate = join(root, "candidate");
     const controller = join(root, "controller");
@@ -76,56 +109,46 @@ if (process.argv[2] === "mcp") {
 } else { process.exitCode = 1; }
 `,
     );
-    const packed = await execute(
-      "npm",
-      ["pack", "--ignore-scripts", "--json"],
-      {
-        cwd: candidate,
-      },
-    );
+    const pack = async () => {
+      const result = await processes.run(
+        "npm",
+        ["pack", "--ignore-scripts", "--json"],
+        { cwd: candidate, timeoutMs: 30_000 },
+      );
+      expect(result.exitCode, result.stderr).toBe(0);
+      return result;
+    };
+    const packed = await pack();
     const [{ filename }] = z
       .tuple([z.object({ filename: z.string() })])
       .parse(JSON.parse(packed.stdout));
     const tarball = join(candidate, filename);
-    for (const file of [
-      "scripts/verify-release-artifact.mjs",
-      "scripts/lib/release-package-canary.mjs",
-      "scripts/lib/verify-package-core.mjs",
-      "scripts/lib/mcp-verifier-results.mjs",
-      "scripts/lib/verifier-run.mjs",
-    ]) {
-      const target = join(controller, file);
-      await mkdir(dirname(target), { recursive: true });
-      await copyFile(file, target);
-    }
-    await writeFile(
-      join(controller, "package.json"),
-      JSON.stringify({ name: "rea-agents", version, type: "module" }),
-    );
-    await symlink(
-      resolve("node_modules"),
-      join(controller, "node_modules"),
-      process.platform === "win32" ? "junction" : "dir",
-    );
+    await prepareController(controller, version);
     const invoke = (selected = tarball) =>
-      execute(
+      processes.run(
         process.execPath,
         [
           join(controller, "scripts/verify-release-artifact.mjs"),
           selected,
           version,
         ],
-        { cwd: controller, maxBuffer: 16 * 1024 * 1024 },
+        {
+          cwd: controller,
+          timeoutMs: Math.min(2_147_483_647, preparationBudget + 30_000),
+        },
       );
-    await expect(invoke()).rejects.toMatchObject({
-      stderr: expect.stringContaining("ERR_MODULE_NOT_FOUND"),
-    });
+    const missing = await invoke();
+    expect(missing.exitCode).toBe(1);
+    expect(missing.stderr).toContain("ERR_MODULE_NOT_FOUND");
+    expect(missing.stderr).toMatch(/dist[/\\]catalogIdentity\.js/u);
     await symlink(
       resolve("dist"),
       join(controller, "dist"),
       process.platform === "win32" ? "junction" : "dir",
     );
-    const result = JSON.parse((await invoke()).stdout);
+    const successful = await invoke();
+    expect(successful.exitCode, successful.stderr).toBe(0);
+    const result = JSON.parse(successful.stdout);
     expect(result).toMatchObject({
       package: "rea-agents",
       version,
@@ -144,12 +167,10 @@ if (process.argv[2] === "mcp") {
       join(candidate, "scripts/reply.json"),
       JSON.stringify(snapshot),
     );
-    await execute("npm", ["pack", "--ignore-scripts", "--json"], {
-      cwd: candidate,
-    });
-    await expect(invoke()).rejects.toMatchObject({
-      stderr: expect.stringContaining("invalid canonical tool catalog"),
-    });
+    await pack();
+    const drifted = await invoke();
+    expect(drifted.exitCode).toBe(1);
+    expect(drifted.stderr).toContain("invalid canonical tool catalog");
     await writeFile(
       join(candidate, "package.json"),
       JSON.stringify({
@@ -159,15 +180,12 @@ if (process.argv[2] === "mcp") {
         files: ["scripts"],
       }),
     );
-    const wrong = await execute("npm", ["pack", "--ignore-scripts", "--json"], {
-      cwd: candidate,
-    });
+    const wrong = await pack();
     const [{ filename: wrongFilename }] = z
       .tuple([z.object({ filename: z.string() })])
       .parse(JSON.parse(wrong.stdout));
-    await expect(invoke(join(candidate, wrongFilename))).rejects.toMatchObject({
-      stderr: expect.stringContaining("Installed package identity"),
-    });
+    const mismatched = await invoke(join(candidate, wrongFilename));
+    expect(mismatched.exitCode).toBe(1);
+    expect(mismatched.stderr).toContain("Installed package identity");
   },
-  30_000,
 );

tests/boundary/providers/native/nativeProvider.test.ts

@@ -30,6 +30,7 @@ import {
   machoImage,
 } from "../../../../src/artifacts/apple/MachoImage.fixture.js";
 import { inspectionImage } from "../../../../src/native/NativeMachoInspection.fixture.js";
+import { fat } from "../../../../src/domain/binaryTarget.fixture.js";
 import {
   inspectPlistSchema,
   inspectSignatureSchema,
@@ -94,6 +95,13 @@ const inspectionFixture = async (high = false) => {
   return nativeMachoTargetForFile(path);
 };
 
+const architectureTargetFixture = async () => {
+  const root = await createTestTempDirectory("rea-native-architectures-");
+  const path = join(root, "fixture");
+  await writeFile(path, fat([0x01000007, 0x0100000c]));
+  return nativeMachoTargetForFile(path);
+};
+
 const cleanupOwner = (runId: string): ProviderProcessSupervisor => {
   const child = Object.assign(new EventEmitter(), {
     stdout: new PassThrough(),
@@ -538,7 +546,7 @@ describe("native owned cancellation boundary", () => {
         launcher,
       );
       const client = new NativeMacOSProvider({}, runner, "darwin").createClient(
-        machoTarget("/private/fixture"),
+        await architectureTargetFixture(),
       );
       const controller = new AbortController();
       const cancellationReason = {
@@ -653,7 +661,7 @@ describe("native cancellation cleanup provenance", () => {
         launcher,
       );
       const client = new NativeMacOSProvider({}, runner, "darwin").createClient(
-        machoTarget("/private/fixture"),
+        await architectureTargetFixture(),
       );
       const controllers = [new AbortController(), new AbortController()];
       const cancellationReason = { source: "mixed native owner retry" };
@@ -790,7 +798,7 @@ describe("native returned cleanup ownership", () => {
         launcher,
       );
       const client = new NativeMacOSProvider({}, runner, "darwin").createClient(
-        machoTarget("/private/fixture"),
+        await architectureTargetFixture(),
       );
       const controller = new AbortController();
       const cancellationReason = { source: "native cleanup retry regression" };
@@ -934,7 +942,7 @@ describe("native late cancellation with cleanup", () => {
       launcher,
     );
     const client = new NativeMacOSProvider({}, runner, "darwin").createClient(
-      machoTarget("/private/fixture"),
+      await architectureTargetFixture(),
     );
     try {
       const pending = client.execute(
@@ -1130,7 +1138,7 @@ describe("native command cleanup lifecycle", () => {
       },
     };
     const client = new NativeMacOSProvider({}, runner, "darwin").createClient(
-      machoTarget("/private/fixture"),
+      await architectureTargetFixture(),
     );
 
     const execution = client.execute("list_architectures", {});
@@ -1216,7 +1224,7 @@ describe("native command failure projection", () => {
       retryCleanup: async () => failures,
     };
     const client = new NativeMacOSProvider({}, runner, "darwin").createClient(
-      machoTarget("/private/fixture"),
+      await architectureTargetFixture(),
     );
     try {
       const result = await client.execute("list_architectures", {});
@@ -1268,7 +1276,7 @@ describe("native command failure projection", () => {
       },
     };
     const result = await new NativeMacOSProvider({}, runner, "darwin")
-      .createClient(machoTarget("/private/fixture"))
+      .createClient(await architectureTargetFixture())
       .execute("list_architectures", {});
 
     expect(result.ok).toBe(false);
@@ -1309,7 +1317,7 @@ describe("native command failure projection", () => {
         },
       };
       const result = await new NativeMacOSProvider({}, runner, "darwin")
-        .createClient(machoTarget("/private/fixture"))
+        .createClient(await architectureTargetFixture())
         .execute("list_architectures", {});
 
       expect(result.ok).toBe(false);
@@ -1429,7 +1437,7 @@ describe("native macOS provider inspection", () => {
     const app = join(directory, "Fixture.app");
     const executable = join(app, "Contents/MacOS/Fixture");
     await mkdir(join(app, "Contents/MacOS"), { recursive: true });
-    await writeFile(executable, "fixture");
+    await writeFile(executable, fat([0x01000007, 0x0100000c]));
     await writeFixturePlist(join(app, "Contents/Info.plist"));
     const externalPlist = join(directory, "Outside.plist");
     await writeFixturePlist(externalPlist);
@@ -1697,7 +1705,7 @@ describe("native macOS provider failures and parsing", () => {
       {},
       new FailingRunner("unavailable"),
       "darwin",
-    ).createClient(machoTarget("/fixture"));
+    ).createClient(await architectureTargetFixture());
     const unavailableResult = await unavailable.execute(
       "list_architectures",
       {},
@@ -1714,7 +1722,7 @@ describe("native macOS provider failures and parsing", () => {
       {},
       new FixtureRunner({ lipo: "malformed" }),
       "darwin",
-    ).createClient(machoTarget("/fixture"));
+    ).createClient(await architectureTargetFixture());
     const malformedResult = await malformed.execute("list_architectures", {});
     expect(!malformedResult.ok && malformedResult.error._tag).toBe(
       "AnalysisOutputError",
@@ -1728,7 +1736,7 @@ describe("native macOS provider failures and parsing", () => {
         {},
         new FailingRunner(reason),
         "darwin",
-      ).createClient(machoTarget("/fixture"));
+      ).createClient(await architectureTargetFixture());
       const result = await client.execute("list_architectures", {});
       expect(!result.ok && result.error._tag).toBe(tag);
     }

tests/conformance/ghidra/README.md

@@ -21,6 +21,12 @@ no-overwrite CLI delivery. It checks the target and project files for changes.
   Clang/LLD/LLVM readelf/LLVM objdump; `REA_RISCV_CLANG`, `REA_RISCV_LLD`,
   `REA_RISCV_READELF` and `REA_RISCV_OBJDUMP` select existing tool commands.
 
+- `ReaInstructionContextProbe.java` inspects source-owned ARM, Thumb, MIPS32
+  and MIPS16 instructions through the production bridge in an ephemeral,
+  read-only Ghidra project. It checks exact decoder-context register names,
+  values and provenance; the ARM lane also injects an unavailable provider
+  value. The `ghidra-bridge-sources` CI job runs both processor families. The
+  input bytes are never executed.
 - `ReaDecodeProbe.java` decodes source-owned instruction bytes from a
   language's default context and checks each mnemonic, length and optional
   complete operand. The `ghidra-bridge-sources` CI job runs it for `ARM:LE:32:Cortex`,

tests/conformance/ghidra/ReaInstructionContextProbe.java

@@ -15,16 +15,20 @@ import java.lang.reflect.Proxy;
 import java.math.BigInteger;
 
 /** Real ARM/Thumb decoding; only the unavailable context value is injected. */
-public class ReaArmContextProbe extends GhidraScript {
+public class ReaInstructionContextProbe extends GhidraScript {
     @Override
     public void run() throws Exception {
         String[] args = getScriptArgs();
-        require(args.length == 1, "Expected the exact production bridge directory");
+        require(args.length == 1 || (args.length == 2 && args[1].equals("mips")), "Expected the bridge directory and optional MIPS mode");
         var source = GhidraScriptUtil.findScriptByName("ReaGhidraBridge.java");
         require(source != null && new File(source.getAbsolutePath()).getCanonicalFile().equals(
             new File(args[0], "ReaGhidraBridge.java").getCanonicalFile()), "Production bridge source");
         GhidraScript bridge = GhidraScriptUtil.getProvider(source).getScriptInstance(source, errorWriter);
         bridge.set(getState(), getControls());
+        if (args.length == 2) {
+            checkMips(bridge);
+            return;
+        }
         require(currentProgram.getLanguageID().getIdAsString().equals("ARM:LE:32:v7"), "ARM fixture language");
         var mode = currentProgram.getRegister("TMode");
         require(mode != null, "Real TMode register");
@@ -40,8 +44,8 @@ public class ReaArmContextProbe extends GhidraScript {
         space.set(null, arm.getAddressSpace());
         Method inspect = bridge.getClass().getDeclaredMethod("inspectNativeInstruction", JsonObject.class, boolean.class);
         inspect.setAccessible(true);
-        check(inspect, bridge, arm, "0", 4, "1eff2fe1");
-        check(inspect, bridge, thumb, "1", 2, "7047");
+        check(inspect, bridge, arm, "0", 4, "1eff2fe1", "TMode");
+        check(inspect, bridge, thumb, "1", 2, "7047", "TMode");
 
         // getValue includes language defaults. Inject only its unavailable result,
         // preserving the real instruction, register, language and all other APIs.
@@ -57,26 +61,49 @@ public class ReaArmContextProbe extends GhidraScript {
         programField.setAccessible(true);
         try {
             programField.set(bridge, program);
-            check(inspect, bridge, arm, null, 4, "1eff2fe1");
+            check(inspect, bridge, arm, null, 4, "1eff2fe1", "TMode");
         } finally {
             programField.set(bridge, original);
         }
         println("REA_ARM_CONTEXT_OK arm=0 thumb=1 unavailable=null (injected provider value)");
     }
 
+    private void checkMips(GhidraScript bridge) throws Exception {
+        require(currentProgram.getLanguageID().getIdAsString().equals("MIPS:LE:32:default"), "MIPS fixture language");
+        var mode = currentProgram.getRegister("ISA_MODE");
+        require(mode != null, "Real ISA_MODE register");
+        Address standard = currentProgram.getMemory().getMinAddress();
+        Address compressed = standard.add(4);
+        var context = currentProgram.getProgramContext();
+        context.setValue(mode, standard, standard.add(3), BigInteger.ZERO);
+        require(disassemble(standard), "MIPS32 instruction decoded");
+        // MIPS32 flow may have decoded following bytes in the default mode.
+        clearListing(compressed, compressed.add(3));
+        context.setValue(mode, compressed, compressed.add(1), BigInteger.ONE);
+        require(disassemble(compressed), "MIPS16 instruction decoded");
+        Field space = bridge.getClass().getDeclaredField("sessionDefaultAddressSpace");
+        space.setAccessible(true);
+        space.set(null, standard.getAddressSpace());
+        Method inspect = bridge.getClass().getDeclaredMethod("inspectNativeInstruction", JsonObject.class, boolean.class);
+        inspect.setAccessible(true);
+        check(inspect, bridge, standard, "0", 4, "03008224", "ISA_MODE");
+        check(inspect, bridge, compressed, "1", 2, "5a6a", "ISA_MODE");
+        println("REA_MIPS_CONTEXT_OK standard=0 mips16=1");
+    }
+
     private static void check(Method inspect, Object bridge, Address address, String mode,
-            int length, String bytes) throws Exception {
+            int length, String bytes, String register) throws Exception {
         JsonObject input = new JsonObject();
         input.add("document", JsonNull.INSTANCE);
         input.addProperty("address", "0x" + Long.toUnsignedString(address.getOffset(), 16));
         JsonObject result = (JsonObject) inspect.invoke(bridge, input, false);
-        require(result.get("status").getAsString().equals("decoded"), "Decoded bridge response");
-        require(result.get("length").getAsInt() == length, "ARM/Thumb instruction width");
+        require(result.get("status").getAsString().equals("decoded"), "Decoded bridge response: " + result);
+        require(result.get("length").getAsInt() == length, "Instruction width");
         require(result.get("bytes").getAsString().equals(bytes), "Original instruction bytes");
         var contexts = result.getAsJsonArray("decoder_context");
         require(contexts != null && contexts.size() == 1, "One retained mode context");
         var value = contexts.get(0).getAsJsonObject();
-        require(value.get("register").getAsString().equals("TMode"), "TMode register name");
+        require(value.get("register").getAsString().equals(register), "Exact context register name");
         require(value.get("source").getAsString().equals("ghidra-program-context"), "Context provenance");
         require(mode == null ? value.get("value").isJsonNull()
             : mode.equals(value.get("value").getAsString()), "Exact mode value " + mode);

tests/fixtures/artifactReaderLifecycle.ts

@@ -252,3 +252,74 @@ export const artifactReaderLifecycleCases = (setup: LifecycleFixture): void => {
     validationCases(setup);
   });
 };
+
+/** An interrupted preparation belongs to its caller, not concurrent readers. */
+export const artifactPreparationRecoveryCases = ({
+  image,
+  createReader,
+}: LifecycleFixture): void => {
+  it.each(["cancelled", "physical failure"] as const)(
+    "preserves independent preparation after %s",
+    async (scenario) => {
+      const path = await fixture(image());
+      const admitted = await openRegularFile(path, { symlinks: "reject" });
+      const reader = createReader(path, admitted);
+      const controller = new AbortController();
+      const reason = { request: "first inventory" };
+      const physical = Object.assign(new Error("controlled read failure"), {
+        code: "EIO",
+      });
+      const reached = createDeferred<void>();
+      const release = createDeferred<void>();
+      const nativeRead = admitted.handle.read.bind(admitted.handle);
+      let blocked = false;
+      const read = vi.spyOn(admitted.handle, "read").mockImplementation((async (
+        ...args: unknown[]
+      ) => {
+        const result = await Reflect.apply(nativeRead, admitted.handle, args);
+        if (!blocked) {
+          blocked = true;
+          reached.resolve();
+          await release.promise;
+          if (scenario === "physical failure") throw physical;
+        }
+        return result;
+      }) as typeof admitted.handle.read);
+      const pending: Promise<unknown>[] = [];
+      try {
+        const first = (async () => {
+          for await (const _ of reader.entries(controller.signal)) {
+          }
+        })();
+        pending.push(first);
+        void first.catch(() => undefined);
+        await awaitAcknowledgement(reached.promise, first, "preparation read");
+        const peer = entries(reader);
+        pending.push(peer);
+        void peer.catch(() => undefined);
+        controller.abort(reason);
+        release.resolve();
+        if (scenario === "physical failure") {
+          await expect(first).rejects.toBe(physical);
+          await expect(peer).rejects.toBe(physical);
+        } else {
+          await expect(first).rejects.toMatchObject({
+            reason: "cancelled",
+            cause: reason,
+          });
+          const recovered = await peer;
+          expect(recovered.length).toBeGreaterThan(0);
+          expect(
+            (await buffer(await reader.open(recovered[0]!))).length,
+          ).toBeGreaterThan(0);
+        }
+      } finally {
+        release.resolve();
+        await Promise.allSettled(pending);
+        read.mockRestore();
+        await reader.close();
+        await admitted.handle.close();
+      }
+    },
+  );
+};