rea-agents 6.3.0 → 6.5.0

package/dist/application/rust/RustBinaryService.js

@@ -0,0 +1,80 @@
+import { isAbsolute } from "node:path";
+import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { BINARY_ARCHITECTURES } from "../../domain/binaryTargetTypes.js";
+import { inspectRustBinaryInputSchema, rustBinarySchema, } from "../../domain/rust/rustBinary.js";
+import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
+import { err, ok } from "../../domain/result.js";
+const OPERATION = "inspect_rust_binary";
+const architectureForSubject = (architecture) => {
+    switch (architecture) {
+        case "386":
+            return "x86";
+        case "amd64":
+            return "x86_64";
+        default:
+            return BINARY_ARCHITECTURES.find((supported) => supported === architecture);
+    }
+};
+/** Shared exact input validation and artifact-bound Evidence for CLI and MCP. */
+export class RustBinaryService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /** Inspect one explicitly selected file without acquiring a binary session. */
+    async inspect(rawInput, options) {
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION));
+        const input = inspectRustBinaryInputSchema.safeParse(rawInput);
+        if (!input.success)
+            return err(analysisInputErrorFromIssues(OPERATION, input.error.issues, rawInput, {
+                cause: input.error,
+            }));
+        if (!isAbsolute(input.data.path))
+            return err(new AnalysisInputError(OPERATION, undefined, [
+                {
+                    path: ["path"],
+                    reason: "invalid_format",
+                    message: "Expected an absolute filesystem path on this host.",
+                },
+            ]));
+        const inspected = await this.provider.inspect(input.data, options);
+        if (!inspected.ok)
+            return inspected;
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION));
+        const report = rustBinarySchema.safeParse(inspected.value);
+        if (!report.success || report.data.artifact.path !== input.data.path)
+            return err(new AnalysisOutputError(OPERATION, "Rust dependency reader returned malformed metadata or changed the selected artifact identity."));
+        return ok(evidenceFor(this.provider.identity, input.data, report.data));
+    }
+}
+const evidenceFor = (provider, parameters, value) => {
+    const architecture = architectureForSubject(value.architecture);
+    const section = value.auditable_metadata;
+    return createEvidence({
+        path: value.artifact.path,
+        sha256: value.artifact.sha256,
+        format: value.format === "macho" ? "mach-o" : value.format,
+        ...(architecture === undefined ? {} : { architecture }),
+    }, provider, {
+        operation: OPERATION,
+        parameters,
+        result: value,
+        confidence: "observed",
+        limitations: value.limitations,
+        locations: [
+            { kind: "artifact-path", path: value.artifact.path },
+            ...(section === null
+                ? []
+                : [
+                    {
+                        kind: "file-offset-range",
+                        start: section.file_offset,
+                        end: section.file_offset + section.section_bytes,
+                    },
+                ]),
+        ],
+    });
+};

package/dist/application/signals/SignalRecordingService.js

@@ -0,0 +1,83 @@
+import { inspectSignalDecodersInputSchema, signalDecodersSchema, } from "../../domain/signals/signalDecoders.js";
+import { isAbsolute } from "node:path";
+import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
+import { decodeSignalRecordingInputSchema, signalRecordingSchema, } from "../../domain/signals/signalRecording.js";
+import { err, ok } from "../../domain/result.js";
+/** One shared validation and Evidence owner for CLI and MCP. */
+export class SignalRecordingService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    close() {
+        return this.provider.close();
+    }
+    async decode(raw, options) {
+        const operation = "decode_signal_recording";
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(operation));
+        const input = decodeSignalRecordingInputSchema.safeParse(raw);
+        if (!input.success)
+            return err(analysisInputErrorFromIssues(operation, input.error.issues, raw, {
+                cause: input.error,
+            }));
+        if (!isAbsolute(input.data.path))
+            return err(new AnalysisInputError(operation, undefined, [
+                {
+                    path: ["path"],
+                    reason: "invalid_format",
+                    message: "Expected an absolute local path.",
+                },
+            ]));
+        const decoded = await this.provider.decode(input.data, options);
+        if (!decoded.ok)
+            return decoded;
+        const execution = decoded.value;
+        const report = signalRecordingSchema.safeParse(execution.result);
+        if (!report.success ||
+            report.data.artifact.path !== input.data.path ||
+            execution.subject?.path !== input.data.path ||
+            execution.subject.sha256 !== report.data.artifact.sha256 ||
+            JSON.stringify(report.data.selection) !== JSON.stringify(input.data))
+            return err(new AnalysisOutputError(operation, "Decoder returned malformed data or changed the selected recording identity/options."));
+        return this.#evidence(operation, input.data, execution, options);
+    }
+    async inspectDecoders(raw, options) {
+        const operation = "inspect_signal_decoders";
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(operation));
+        const input = inspectSignalDecodersInputSchema.safeParse(raw);
+        if (!input.success)
+            return err(analysisInputErrorFromIssues(operation, input.error.issues, raw, {
+                cause: input.error,
+            }));
+        const decoded = await this.provider.inspectDecoders(input.data, options);
+        if (!decoded.ok)
+            return decoded;
+        const execution = decoded.value;
+        const report = signalDecodersSchema.safeParse(execution.result);
+        if (!report.success ||
+            JSON.stringify(report.data.selection) !== JSON.stringify(input.data) ||
+            execution.subject?.path !== report.data.tool.path ||
+            execution.subject.sha256 !== report.data.tool.sha256)
+            return err(new AnalysisOutputError(operation, "Decoder discovery returned malformed data or changed the selected installation/options."));
+        return this.#evidence(operation, input.data, execution, options);
+    }
+    #evidence(operation, parameters, execution, options) {
+        const evidence = createEvidence(execution.subject ?? undefined, execution.provider, {
+            operation,
+            parameters,
+            result: execution.result,
+            confidence: "observed",
+            locations: execution.locations,
+            limitations: execution.limitations,
+        });
+        return options?.signal?.aborted
+            ? err(new AnalysisCancelledError(operation, {
+                partialObservation: evidence,
+            }))
+            : ok(evidence);
+    }
+}

package/dist/application/sqlite/SqliteDatabaseCapability.js

@@ -0,0 +1,30 @@
+import { satisfies } from "semver";
+import { toolContract } from "../../contracts/toolContracts.js";
+import { SQLITE_PROVIDER_IDENTITY } from "../../domain/sqlite/sqliteDatabase.js";
+const SQLITE_RUNTIME_REQUIREMENT = "SQLite inspection requires Node.js 24.x >=24.15 or 26+ with the native DatabaseSync.limits API. Other REA features retain their published runtime requirements. The inspection worker verifies the API before querying the snapshot.";
+/** Discover inspection readiness without opening a database or starting a worker. */
+export const sqliteDatabaseCapability = (nodeVersion) => {
+    const contract = toolContract("inspect_sqlite_database");
+    const facts = {
+        operation: contract.name,
+        provider: SQLITE_PROVIDER_IDENTITY,
+        effects: {
+            mutatesArtifact: contract.effects.mutatesTarget,
+            launchesProcess: contract.effects.launchesProcess,
+            mayShowUi: contract.effects.changesUiState,
+            mayAccessNetwork: contract.effects.accessesNetwork,
+            mayWriteFilesystem: contract.effects.writesFilesystem,
+            changesPermissions: false,
+            requiresRoot: false,
+        },
+        limitations: [SQLITE_RUNTIME_REQUIREMENT],
+    };
+    return satisfies(nodeVersion, "^24.15.0 || >=26.0.0")
+        ? { ...facts, available: true, reason: null }
+        : {
+            ...facts,
+            available: false,
+            reason: SQLITE_RUNTIME_REQUIREMENT,
+            availabilityCode: "unsupported_version",
+        };
+};

package/dist/application/sqlite/SqliteDatabasePort.js

@@ -0,0 +1 @@
+export {};

package/dist/application/sqlite/SqliteDatabaseService.js

@@ -0,0 +1,76 @@
+import { isAbsolute } from "node:path";
+import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { createEvidence, } from "../../domain/evidence.js";
+import { inspectSqliteDatabaseInputSchema, sqliteDatabaseSchema, SQLITE_ROW_LIMIT_DEFAULT, sqliteSchemaScope, sqliteInspectionParameters, } from "../../domain/sqlite/sqliteDatabase.js";
+import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
+import { err, ok } from "../../domain/result.js";
+import { jsonValueSchema } from "../../domain/jsonValue.js";
+const OPERATION = "inspect_sqlite_database";
+const matchesSelectedDatabase = (report, input, subject) => report.artifact.path === input.path &&
+    subject.path === input.path &&
+    subject.sha256 === report.artifact.sha256 &&
+    subject.format === "file" &&
+    (report.wal === null || report.wal.path === `${input.path}-wal`) &&
+    report.schema.scope === sqliteSchemaScope(input) &&
+    (report.schema.scope !== "selected_table" ||
+        (report.schema.tables.length === 1 &&
+            report.schema.tables[0]?.name === input.table &&
+            report.schema.indexes.every((index) => index.table === input.table) &&
+            report.schema.triggers.every((trigger) => trigger.table === input.table) &&
+            report.schema.views.length === 0)) &&
+    (input.table === undefined
+        ? report.rows === null
+        : report.rows?.table === input.table &&
+            report.rows.row_limit === (input.row_limit ?? SQLITE_ROW_LIMIT_DEFAULT) &&
+            (input.columns === undefined ||
+                (report.rows.columns.length === input.columns.length &&
+                    report.rows.columns.every((name, index) => name === input.columns?.[index]))));
+/** Shared snapshot inspection and caller-selection validation for CLI and MCP. */
+export class SqliteDatabaseService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /** Await provider shutdown, retaining failed cleanup owners for retry. */
+    close() {
+        return this.provider.close?.() ?? Promise.resolve();
+    }
+    /** Inspect an explicit database snapshot and preserve its original database/WAL identity. */
+    async inspect(rawInput, options) {
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION));
+        const input = inspectSqliteDatabaseInputSchema.safeParse(rawInput);
+        if (!input.success)
+            return err(analysisInputErrorFromIssues(OPERATION, input.error.issues, rawInput, {
+                cause: input.error,
+            }));
+        if (!isAbsolute(input.data.path))
+            return err(new AnalysisInputError(OPERATION, undefined, [
+                {
+                    path: ["path"],
+                    reason: "invalid_format",
+                    message: "Expected an absolute filesystem path on this host.",
+                },
+            ]));
+        const inspected = await this.provider.inspect(input.data, options);
+        if (!inspected.ok)
+            return inspected;
+        const execution = inspected.value;
+        const report = sqliteDatabaseSchema.safeParse(execution.result);
+        if (!report.success ||
+            execution.subject === null ||
+            !matchesSelectedDatabase(report.data, input.data, execution.subject))
+            return err(new AnalysisOutputError(OPERATION, "SQLite adapter returned malformed data or changed the selected database identity/table/row limit."));
+        return ok(createEvidence(execution.subject, execution.provider, {
+            operation: OPERATION,
+            parameters: sqliteInspectionParameters(input.data),
+            result: jsonValueSchema.parse(report.data),
+            ...(execution.rawResult === null
+                ? {}
+                : { rawResult: execution.rawResult }),
+            confidence: "observed",
+            locations: execution.locations,
+            limitations: execution.limitations,
+        }));
+    }
+}

package/dist/application/wasm/WasmArtifactPort.js

@@ -0,0 +1 @@
+export {};

package/dist/application/wasm/WasmArtifactService.js

@@ -0,0 +1,77 @@
+import { isAbsolute } from "node:path";
+import { AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { createEvidence } from "../../domain/evidence.js";
+import { inspectWasmArtifactInputSchema, wasmArtifactSchema, wasmArtifactMatchesSubject, } from "../../domain/wasm/wasmArtifact.js";
+import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
+import { err, ok } from "../../domain/result.js";
+const OPERATION = "inspect_wasm_artifact";
+/** Shared artifact validation and typed inline Evidence for CLI/MCP. */
+export class WasmArtifactService {
+    provider;
+    constructor(provider) {
+        this.provider = provider;
+    }
+    /** Join provider cleanup during shutdown or an explicit retry. */
+    close() {
+        return this.provider.close();
+    }
+    /** Preserve exact selected artifact identity and validated upstream observations. */
+    async inspect(rawInput, options) {
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION));
+        const input = inspectWasmArtifactInputSchema.safeParse(rawInput);
+        if (!input.success)
+            return err(analysisInputErrorFromIssues(OPERATION, input.error.issues, rawInput, {
+                cause: input.error,
+            }));
+        const pathIssues = [
+            { value: input.data.path, path: ["path"] },
+            ...input.data.glue_paths.map((value, index) => ({
+                value,
+                path: ["glue_paths", index],
+            })),
+            ...input.data.candidate_paths.map((value, index) => ({
+                value,
+                path: ["candidate_paths", index],
+            })),
+        ].flatMap(({ value, path }) => isAbsolute(value)
+            ? []
+            : [
+                {
+                    path,
+                    reason: "invalid_format",
+                    message: "Expected an absolute filesystem path on this host.",
+                },
+            ]);
+        if (pathIssues.length > 0)
+            return err(new AnalysisInputError(OPERATION, undefined, pathIssues));
+        const inspected = await this.provider.inspect(input.data, options);
+        if (!inspected.ok)
+            return inspected;
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION));
+        const execution = inspected.value;
+        const report = wasmArtifactSchema.safeParse(execution.result);
+        if (!report.success ||
+            report.data.artifact.path !== input.data.path ||
+            !wasmArtifactMatchesSubject(report.data.artifact, execution.subject) ||
+            JSON.stringify(report.data.glue.map((item) => item.artifact.path)) !==
+                JSON.stringify(input.data.glue_paths) ||
+            JSON.stringify(report.data.candidates.map((item) => item.path)) !==
+                JSON.stringify([
+                    ...new Set([input.data.path, ...input.data.candidate_paths]),
+                ]))
+            return err(new AnalysisOutputError(OPERATION, "WABT adapter returned malformed data or changed the selected artifact identity."));
+        return ok(createEvidence(execution.subject, execution.provider, {
+            operation: OPERATION,
+            parameters: input.data,
+            result: report.data,
+            ...(execution.rawResult === null
+                ? {}
+                : { rawResult: execution.rawResult }),
+            confidence: "observed",
+            locations: execution.locations,
+            limitations: execution.limitations,
+        }));
+    }
+}

package/dist/application/wasm/WasmInterfaceComparisonService.js

@@ -0,0 +1,188 @@
+import { WASM_INTERFACE_REPRESENTATION_BYTES, wasmInterfaceEntryRepresentationBytes, } from "../../domain/wasm/wasmInterface.js";
+import { setImmediate } from "node:timers/promises";
+import { compareWasmInterfacesInputSchema, wasmInterfaceComparisonSchema, } from "../../contracts/wasm/wasmComparisonContracts.js";
+import { createEvidence, parseEvidence, } from "../../domain/evidence.js";
+import { wasmArtifactSchema, } from "../../domain/wasm/wasmArtifact.js";
+import { AnalysisCancelledError, AnalysisInputError, AnalysisResourceConstraintError, } from "../../domain/analysisErrorCore.js";
+import { AnalysisError } from "../../domain/analysisErrorBase.js";
+import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
+import { err, ok } from "../../domain/result.js";
+import { ARTIFACT_COMPARISON_PROVIDER } from "../InvestigationProviders.js";
+import { resolvePairedEvidenceRequest, } from "../EvidenceInputResolver.js";
+const OPERATION = "compare_wasm_interfaces";
+const parseInspection = (raw) => {
+    const evidence = parseEvidence(raw);
+    if (evidence.operation !== "inspect_wasm_artifact")
+        throw new TypeError("Expected complete inspect_wasm_artifact Evidence");
+    const result = wasmArtifactSchema.parse(evidence.normalized_result);
+    if (evidence.subject?.digest.sha256 !== result.artifact.sha256 ||
+        evidence.subject.local_path !== result.artifact.path ||
+        evidence.parameters.path !== result.artifact.path)
+        throw new TypeError("WASM Evidence subject/selection does not match normalized artifact identity");
+    return { evidence, result };
+};
+/** Compare only producer-owned typed facts; no raw WAT or original file is reread. */
+export const compareWasmInterfaces = async (rawInput, options, lookup) => {
+    if (options?.signal?.aborted)
+        return err(new AnalysisCancelledError(OPERATION));
+    const parsed = compareWasmInterfacesInputSchema.safeParse(rawInput);
+    if (!parsed.success)
+        return err(analysisInputErrorFromIssues(OPERATION, parsed.error.issues, rawInput));
+    const resolved = resolvePairedEvidenceRequest(parsed.data, lookup);
+    if (!resolved.ok)
+        return resolved;
+    try {
+        await setImmediate();
+        options?.signal?.throwIfAborted();
+        const left = parseInspection(resolved.value.left);
+        const right = parseInspection(resolved.value.right);
+        const scope = parsed.data.scope;
+        const selected = (entry) => scope === "both" ||
+            entry.direction === (scope === "imports" ? "import" : "export");
+        const groups = new Map();
+        let work = 0;
+        for (const [side, inspection] of [
+            ["left", left],
+            ["right", right],
+        ]) {
+            for (const entry of inspection.result.interface?.entries ?? []) {
+                if (++work % 256 === 0) {
+                    await setImmediate();
+                    options?.signal?.throwIfAborted();
+                }
+                if (!selected(entry))
+                    continue;
+                const key = JSON.stringify([entry.direction, entry.module, entry.name]);
+                let group = groups.get(key);
+                if (group === undefined) {
+                    group = { left: [], right: [], entry };
+                    groups.set(key, group);
+                }
+                group[side].push(entry);
+            }
+        }
+        const knownInventory = (inspection) => inspection.result.interface?.state === "complete";
+        const changes = [];
+        const summary = {
+            added: 0,
+            removed: 0,
+            changed: 0,
+            unchanged: 0,
+            unknown: 0,
+        };
+        let remaining = WASM_INTERFACE_REPRESENTATION_BYTES;
+        for (const group of groups.values()) {
+            remaining -=
+                512 +
+                    group.left.reduce((sum, entry) => sum + wasmInterfaceEntryRepresentationBytes(entry), 0) +
+                    group.right.reduce((sum, entry) => sum + wasmInterfaceEntryRepresentationBytes(entry), 0);
+            if (remaining < 0)
+                throw new AnalysisResourceConstraintError(OPERATION, "capacity", "WASM comparison exceeds typed interface representation capacity", { maximum_bytes: WASM_INTERFACE_REPRESENTATION_BYTES });
+            if (++work % 256 === 0) {
+                await setImmediate();
+                options?.signal?.throwIfAborted();
+            }
+            let state;
+            let reason = null;
+            const l = group.left[0];
+            const r = group.right[0];
+            if (group.left.length > 1 || group.right.length > 1) {
+                state = "unknown";
+                reason =
+                    "Duplicate interface names are ambiguous; all occurrences retained";
+            }
+            else if (!knownInventory(left) || !knownInventory(right)) {
+                state = "unknown";
+                reason =
+                    "Incomplete interface inventories cannot establish per-key uniqueness or absence";
+            }
+            else if ([l, r].some((entry) => entry !== undefined &&
+                (entry.signature === null ||
+                    entry.issue !== null ||
+                    entry.kind === "unknown"))) {
+                state = "unknown";
+                reason =
+                    "Signature/type semantics were not admitted for every present entry";
+            }
+            else if (l === undefined)
+                state = "added";
+            else if (r === undefined)
+                state = "removed";
+            else if (l.kind !== r.kind)
+                state = "changed";
+            else
+                state =
+                    JSON.stringify(l.signature) === JSON.stringify(r.signature)
+                        ? "unchanged"
+                        : "changed";
+            summary[state]++;
+            changes.push({
+                direction: group.entry.direction,
+                module: group.entry.module,
+                name: group.entry.name,
+                state,
+                left: group.left,
+                right: group.right,
+                reason,
+            });
+        }
+        const compareText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+        changes.sort((a, b) => compareText(a.direction, b.direction) ||
+            compareText(a.module ?? "", b.module ?? "") ||
+            compareText(a.name, b.name));
+        const coverage = left.result.interface === undefined &&
+            right.result.interface === undefined
+            ? "unknown"
+            : !knownInventory(left) || !knownInventory(right) || summary.unknown > 0
+                ? "partial"
+                : "complete-within-inputs";
+        const limitations = [
+            "Exact declared interface equality is not runtime/ABI compatibility, successful linking or original-source identity.",
+            "Typed facts come from the selected validated WABT decoding; unsupported signature semantics and duplicate names remain unknown.",
+        ];
+        const report = wasmInterfaceComparisonSchema.parse({
+            left: {
+                evidence_id: left.evidence.evidence_id,
+                artifact: left.result.artifact,
+            },
+            right: {
+                evidence_id: right.evidence.evidence_id,
+                artifact: right.result.artifact,
+            },
+            scope,
+            coverage,
+            changes,
+            summary,
+            limitations,
+        });
+        await setImmediate();
+        options?.signal?.throwIfAborted();
+        return ok(createEvidence(undefined, ARTIFACT_COMPARISON_PROVIDER, {
+            operation: OPERATION,
+            predicateType: "rea.wasm-interface-comparison",
+            parameters: {
+                left_evidence_id: left.evidence.evidence_id,
+                right_evidence_id: right.evidence.evidence_id,
+                scope,
+            },
+            result: report,
+            confidence: "derived",
+            authority: "analyst-inference",
+            limitations,
+            evidenceLinks: [left.evidence.evidence_id, right.evidence.evidence_id],
+        }));
+    }
+    catch (cause) {
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION));
+        if (cause instanceof AnalysisError)
+            return err(cause);
+        return err(new AnalysisInputError(OPERATION, { cause }, [
+            {
+                path: [],
+                reason: "invalid_value",
+                message: cause instanceof Error ? cause.message : String(cause),
+            },
+        ]));
+    }
+};

package/dist/artifacts/ArtifactHash.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { ArtifactReaderFailure } from "./ArtifactReader.js";
 import { streamChunkToBuffer } from "./StreamBytes.js";
+import { createXmlPlistSignatureProbe, MAX_XML_PLIST_PROBE_BYTES, } from "../domain/apple/appleArchiveFormat.js";
 /** Bounded classification evidence; this is not an executable format size limit. */
 export const ARTIFACT_CLASSIFICATION_PREFIX_BYTES = 8_192;
 /** Preserve the inventory cancellation reason at a stream boundary. */
@@ -13,16 +14,26 @@ export const hashReadable = async (stream, signal) => {
     const hash = createHash("sha256");
     const prefixes = [];
     let prefixBytes = 0;
+    const xmlProbe = createXmlPlistSignatureProbe();
     let bytes = 0;
     for await (const raw of stream) {
         abortIfNeeded(signal);
         const chunk = streamChunkToBuffer(raw);
         bytes += chunk.length;
         hash.update(chunk);
-        if (prefixBytes < ARTIFACT_CLASSIFICATION_PREFIX_BYTES) {
-            const selected = chunk.subarray(0, ARTIFACT_CLASSIFICATION_PREFIX_BYTES - prefixBytes);
+        let chunkOffset = 0;
+        while (chunkOffset < chunk.length &&
+            (prefixBytes < ARTIFACT_CLASSIFICATION_PREFIX_BYTES ||
+                (xmlProbe.state === "pending" &&
+                    prefixBytes < MAX_XML_PLIST_PROBE_BYTES))) {
+            const limit = prefixBytes < ARTIFACT_CLASSIFICATION_PREFIX_BYTES
+                ? ARTIFACT_CLASSIFICATION_PREFIX_BYTES
+                : MAX_XML_PLIST_PROBE_BYTES;
+            const selected = chunk.subarray(chunkOffset, Math.min(chunkOffset + limit - prefixBytes, chunk.length));
             prefixes.push(selected);
             prefixBytes += selected.length;
+            chunkOffset += selected.length;
+            xmlProbe.write(selected);
         }
     }
     return { sha256: hash.digest("hex"), bytes, prefix: Buffer.concat(prefixes) };