rea-agents 6.3.0 → 6.5.0

package/dist/ida/IdaWorkspace.js

@@ -1,6 +1,6 @@
 import { createHash, randomUUID } from "node:crypto";
-import { createReadStream, constants } from "node:fs";
-import { copyFile } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { open, realpath } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { basename, join, normalize } from "node:path";
 import { AnalysisProtocolError } from "../domain/analysisErrorCore.js";
@@ -22,6 +22,7 @@ export class IdaWorkspace {
     inputPath;
     target;
     sessionId = `rea-${randomUUID()}`;
+    #inputSha256;
     constructor(runtime, inputPath, target) {
         this.runtime = runtime;
         this.inputPath = inputPath;
@@ -31,20 +32,69 @@ export class IdaWorkspace {
     get directory() {
         return this.runtime.path;
     }
+    /** SHA-256 of the private input bytes copyInput admitted; undefined until prepared. */
+    get inputSha256() {
+        return this.#inputSha256;
+    }
     /** Allocate a protected workspace so its owner can retain it before input preparation. */
     static async allocate(target, root = tmpdir()) {
+        // Upstream reports canonical paths (macOS /var -> /private/var), so the
+        // private input path must already be canonical for identity checks.
         const runtime = await PrivateRuntimeRoot.create({
-            parent: normalize(root),
+            parent: await realpath(normalize(root)),
             prefix: "rea-ida-",
         });
         const inputPath = join(runtime.path, basename(target.path));
         return new IdaWorkspace(runtime, inputPath, target);
     }
-    /** Copy and verify admitted bytes after the session owns this workspace's cleanup. */
+    /**
+     * Copy and verify admitted bytes after the session owns this workspace's
+     * cleanup. Universal Mach-O containers are thinned to the selected slice so
+     * the upstream engine analyzes the architecture admission reported; the
+     * whole-source digest still anchors the copy against admission-time changes.
+     */
     async copyInput() {
-        await copyFile(this.target.path, this.inputPath, constants.COPYFILE_EXCL);
-        if ((await idaFileDigest(this.inputPath)) !== this.target.sha256)
-            throw new AnalysisProtocolError("IDA target changed between admission and the private input copy; reopen the target.");
+        const slice = this.target.format === "mach-o-universal"
+            ? this.target.universalSlice
+            : undefined;
+        const source = await open(this.target.path, "r");
+        try {
+            const input = await open(this.inputPath, "wx");
+            try {
+                const sourceHash = createHash("sha256");
+                const inputHash = createHash("sha256");
+                const chunk = Buffer.allocUnsafe(64 * 1024);
+                let position = 0;
+                for (;;) {
+                    const observed = await source.read(chunk, 0, chunk.length, position);
+                    if (observed.bytesRead === 0)
+                        break;
+                    const bytes = chunk.subarray(0, observed.bytesRead);
+                    sourceHash.update(bytes);
+                    const start = slice === undefined ? position : Math.max(position, slice.offset);
+                    const end = slice === undefined
+                        ? position + bytes.length
+                        : Math.min(position + bytes.length, slice.offset + slice.size);
+                    // A chunk after the slice has end < position, and a negative subarray
+                    // bound would count from the chunk's end instead of being empty.
+                    if (end > start) {
+                        const admitted = bytes.subarray(start - position, end - position);
+                        inputHash.update(admitted);
+                        await input.write(admitted);
+                    }
+                    position += observed.bytesRead;
+                }
+                if (sourceHash.digest("hex") !== this.target.sha256)
+                    throw new AnalysisProtocolError("IDA target changed between admission and the private input copy; reopen the target.");
+                this.#inputSha256 = inputHash.digest("hex");
+            }
+            finally {
+                await input.close();
+            }
+        }
+        finally {
+            await source.close();
+        }
     }
     /** Delete only this object's privately allocated directory after worker cleanup. */
     async remove() {

package/dist/inspector/V8InspectorCaptureProjection.js

@@ -5,12 +5,17 @@ export const createInspectorExclusionCounts = () => ({
     unsupported_location: 0,
 });
 /** Stable safety and protocol limitations shared by target-list Evidence. */
-export const describeInspectorTargetLimitations = () => [
+export const describeInspectorTargetLimitations = (attachmentStateUnknown = false) => [
     "REA attaches to an already-running exact target and never launches, resumes, evaluates, pauses, or mutates it.",
     "Only Runtime.enable and Debugger.enable are sent; source text, object values, EventEmitter activity, and Electron IPC are not inspected.",
     "The selected endpoint and target ID authorize observation; discovery file locations can remain unresolved and do not prove filesystem identity.",
     "Node discovery reports a best-effort pathname rather than an encoded file URL; lossy Windows paths and ambiguous underscores are preserved without guessing a file path.",
     "Every target exposed by the selected Inspector endpoint is eligible for observation; target IDs and locations are not authenticated as operating-system process identity.",
+    ...(attachmentStateUnknown
+        ? [
+            "Inspector discovery did not report the target's current debugger attachment state; it is retained as unknown, and observation rejects only targets explicitly marked attached.",
+        ]
+        : []),
     "No runtime graph depth is traversed because passive Inspector events do not establish require/import caller edges.",
 ];
 const LOCATION_AUTHORIZATION_WORKERS = 8;
@@ -159,7 +164,7 @@ export const finalizeInspectorCapture = async ({ input, runtime, target, state,
             "A bounded observation window cannot establish that an unobserved script or behavior never occurs.",
             "The declared Node/Electron process role is not authenticated by the Inspector protocol.",
         ],
-        limitations: describeInspectorTargetLimitations(),
+        limitations: describeInspectorTargetLimitations(target.attached === null),
     };
 };
 const scriptFromDraft = (draft, location) => {

package/dist/inspector/V8InspectorEndpoint.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
-import {} from "../domain/browserObservationErrors.js";
+import { urlDeclaresQueryOrFragment } from "../domain/urlComponents.js";
 import { parseCdpEndpointValue, readCdpJson } from "../browser/CdpEndpoint.js";
 const versionSchema = z
     .object({
@@ -14,8 +14,11 @@ const targetSchema = z
     id: z.string().min(1),
     type: z.string().min(1),
     url: z.string(),
-    attached: z.boolean().default(false),
-    webSocketDebuggerUrl: z.string().min(1),
+    attached: z.boolean().nullable().optional(),
+    // Node may publish anonymous/evaluated targets without a direct socket.
+    // Keep malformed values local to their target so one row cannot discard
+    // otherwise usable siblings from the endpoint inventory.
+    webSocketDebuggerUrl: z.unknown().optional(),
 })
     .passthrough();
 const targetsSchema = z.array(targetSchema);
@@ -37,20 +40,20 @@ export const discoverV8Inspector = async (endpoint, operation, signal) => {
             id: target.id,
             type: target.type,
             url: target.url,
-            attached: target.attached,
-            webSocketUrl: validatedInspectorWebSocket(endpoint, target.id, target.webSocketDebuggerUrl, operation),
+            attached: target.attached ?? null,
+            webSocketUrl: validatedInspectorWebSocket(endpoint, target.id, target.webSocketDebuggerUrl),
         })),
     };
 };
-const validatedInspectorWebSocket = (endpoint, targetId, reported, operation) => {
+const validatedInspectorWebSocket = (endpoint, targetId, reported) => {
+    if (typeof reported !== "string" || reported.length === 0)
+        return null;
     let socket;
     try {
         socket = new URL(reported);
     }
-    catch (cause) {
-        throw new BrowserObservationError(operation, "invalid_endpoint_response", {
-            cause,
-        });
+    catch {
+        return null;
     }
     const trusted = new URL(endpoint);
     const allowedPaths = new Set([
@@ -62,10 +65,9 @@ const validatedInspectorWebSocket = (endpoint, targetId, reported, operation) =>
         socket.port !== trusted.port ||
         socket.username !== "" ||
         socket.password !== "" ||
-        socket.search !== "" ||
-        socket.hash !== "" ||
+        urlDeclaresQueryOrFragment(socket) ||
         !allowedPaths.has(socket.pathname))
-        throw new BrowserObservationError(operation, "invalid_endpoint_response");
+        return null;
     socket.hostname = trusted.hostname;
     return socket.href;
 };

package/dist/inspector/V8InspectorProvider.js

@@ -2,7 +2,6 @@ import { javascriptRuntimeObservationSchema, javascriptRuntimeTargetListSchema,
 import { AnalysisError } from "../domain/analysisErrorBase.js";
 import { BrowserObservationError } from "../domain/browserObservationError.js";
 import { ProviderAdapterError } from "../domain/providerAdapterError.js";
-import {} from "../domain/browserObservationErrors.js";
 import { err, ok } from "../domain/result.js";
 import { numberValue, recordValue, cdpStringValue, scriptMetadataValues, delayWithCancellation, } from "../browser/CdpCaptureValues.js";
 import { CdpConnection } from "../browser/CdpConnection.js";
@@ -25,6 +24,7 @@ export class V8InspectorProvider {
             const discovery = await discoverV8Inspector(input.inspector_endpoint, "list_javascript_runtime_targets", options.signal);
             const allowed = [];
             const excluded = createInspectorExclusionCounts();
+            let unconnectable = 0;
             for (const target of discovery.targets) {
                 const decision = await authorizeRuntimeTargetLocation(target.url, {
                     type: target.type,
@@ -38,14 +38,25 @@ export class V8InspectorProvider {
                     excluded.unsupported_location += 1;
                     continue;
                 }
-                allowed.push({ ...target, location: decision.location });
+                if (target.webSocketUrl === null) {
+                    unconnectable += 1;
+                    continue;
+                }
+                allowed.push({
+                    id: target.id,
+                    type: target.type,
+                    url: target.url,
+                    attached: target.attached,
+                    webSocketUrl: target.webSocketUrl,
+                    location: decision.location,
+                });
             }
             allowed.sort((left, right) => left.id < right.id ? -1 : left.id > right.id ? 1 : 0);
             return ok(javascriptRuntimeTargetListSchema.parse({
                 runtime: discovery.runtime,
                 targets: allowed.map(projectTarget),
-                excluded: { ...excluded, unconnectable: 0 },
-                limitations: describeInspectorTargetLimitations(),
+                excluded: { ...excluded, unconnectable },
+                limitations: describeInspectorTargetLimitations(allowed.some((target) => target.attached === null)),
             }));
         }
         catch (cause) {
@@ -216,11 +227,22 @@ const authorizedTarget = async (targets, input, product) => {
         type: target.type,
         product,
     });
-    if (target.attached ||
+    if (target.attached === true ||
         !decision.allowed ||
         decision.location.kind === "builtin")
         throw new BrowserObservationError("observe_javascript_runtime", "target_not_allowed");
-    return { ...target, location: decision.location };
+    if (target.webSocketUrl === null)
+        throw new BrowserObservationError("observe_javascript_runtime", "invalid_endpoint_response", {
+            detail: "The selected Inspector target has no validated direct WebSocket endpoint.",
+        });
+    return {
+        id: target.id,
+        type: target.type,
+        url: target.url,
+        attached: target.attached,
+        webSocketUrl: target.webSocketUrl,
+        location: decision.location,
+    };
 };
 const assertRuntimeKind = (target, kind) => {
     const accepted = kind === "electron-preload" || kind === "electron-renderer"
@@ -344,17 +366,29 @@ const replaceRetainedMetadata = (state, byteDelta) => {
 };
 const waitForCapture = async (connection, observationMs, signal) => {
     let removeDisconnect = () => undefined;
+    let removeProtocolFailure = () => undefined;
     const disconnected = new Promise((_resolve, reject) => {
         removeDisconnect = connection.onDisconnect((error) => reject(error));
     });
+    const protocolFailure = new Promise((_resolve, reject) => {
+        removeProtocolFailure = connection.onProtocolFailure((error) => reject(error));
+    });
+    const timerOwner = new AbortController();
+    const timerSignal = signal === undefined
+        ? timerOwner.signal
+        : AbortSignal.any([signal, timerOwner.signal]);
     try {
         await Promise.race([
-            delayWithCancellation(observationMs, "observe_javascript_runtime", signal),
+            delayWithCancellation(observationMs, "observe_javascript_runtime", timerSignal),
             disconnected,
+            protocolFailure,
         ]);
     }
     finally {
+        // Cancel only this wait's timer. The caller owns and retains its signal.
+        timerOwner.abort();
         removeDisconnect();
+        removeProtocolFailure();
     }
 };
 const retainedMetadataBytes = (value) => {

package/dist/javascript/analysis/JavaScriptAnalysisTransfer.js

@@ -0,0 +1,337 @@
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { open, stat } from "node:fs/promises";
+import { z } from "zod";
+import { AnalysisResourceConstraintError } from "../../domain/analysisErrorCore.js";
+import { digestSchema } from "../../domain/digests.js";
+import { javaScriptWorkerGraphRecordSchema, javaScriptWorkerModuleHeaderSchema, javaScriptWorkerModuleRecordSchema, javaScriptWorkerProjectionHeaderSchema, } from "./JavaScriptAnalysisWorkerSchemas.js";
+// Budgets bound transfer representation, independently of source length.
+/** Record bound whose transient decoding expansion is reserved by the consumer. */
+export const JAVASCRIPT_ANALYSIS_TRANSFER_RECORD_BYTES = 8 * 1024 * 1024;
+const FRAME_BYTES = JAVASCRIPT_ANALYSIS_TRANSFER_RECORD_BYTES;
+const TRANSFER_BYTES = 512 * 1024 * 1024;
+const MAX_TRANSFER_BYTES = 2 * 1024 * 1024 * 1024;
+const BATCH_BYTES = 1024 * 1024;
+const recordSchema = z.discriminatedUnion("kind", [
+    z.strictObject({
+        kind: z.literal("projection-header"),
+        value: javaScriptWorkerProjectionHeaderSchema,
+    }),
+    z.strictObject({
+        kind: z.literal("module-header"),
+        value: javaScriptWorkerModuleHeaderSchema,
+    }),
+    ...javaScriptWorkerGraphRecordSchema.options,
+    ...javaScriptWorkerModuleRecordSchema.options,
+]);
+/** Complete-file coordinates authenticated before adopting any worker facts. */
+export const javaScriptAnalysisTransferDescriptorSchema = z.strictObject({
+    bytes: z.number().int().nonnegative().max(MAX_TRANSFER_BYTES),
+    sha256: digestSchema,
+    records: z.number().int().nonnegative(),
+    module_bytes: z.number().int().nonnegative(),
+    module_records: z.number().int().nonnegative(),
+    graph_bytes: z.number().int().nonnegative(),
+    graph_records: z.number().int().nonnegative(),
+});
+/** Conservative retained-object and sealing expansion for validated transfer rows. */
+export const javaScriptTransferRetentionBytes = (bytes, records) => bytes * 8 + records * 64;
+/** Larger streamed files require corresponding parent admission capacity. */
+export const javaScriptTransferByteBudget = (resultBudgetBytes) => Math.min(MAX_TRANSFER_BYTES, Math.max(TRANSFER_BYTES, Math.floor(resultBudgetBytes / 8)));
+const assertTransferByteBudget = (transferBytes) => {
+    if (!Number.isSafeInteger(transferBytes) ||
+        transferBytes < 1 ||
+        transferBytes > MAX_TRANSFER_BYTES)
+        throw new RangeError("JavaScript transfer requires a valid complete-file byte budget");
+};
+const encodeTransferRecord = (input, previousBytes, transferBytes = TRANSFER_BYTES) => {
+    const record = recordSchema.parse(input);
+    const line = `${JSON.stringify(record)}\n`;
+    const size = Buffer.byteLength(line);
+    if (size > FRAME_BYTES || previousBytes + size > transferBytes)
+        throw new AnalysisResourceConstraintError("analyze_javascript_application", "transport", size > FRAME_BYTES
+            ? "A complete JavaScript fact exceeds the transfer record byte budget"
+            : "Complete JavaScript file facts exceed the transfer byte budget", {
+            transfer_record_bytes: FRAME_BYTES,
+            transfer_file_bytes: transferBytes,
+            record_bytes: size,
+            transfer_bytes_at_least: previousBytes + size,
+        });
+    return { line, size, kind: record.kind };
+};
+function* moduleTransferRecords(module) {
+    yield {
+        kind: "module-header",
+        value: { coverage: module.coverage, limitations: module.limitations },
+    };
+    for (const value of module.scopes)
+        yield { kind: "scope", value };
+    for (const value of module.bindings)
+        yield { kind: "binding", value };
+    for (const value of module.callables)
+        yield { kind: "callable", value };
+    for (const value of module.moduleLinks)
+        yield { kind: "module-link", value };
+}
+/** Measure actual validated module rows before allocating an unadmittable graph. */
+export const measureJavaScriptModuleTransfer = (module, transferBytes = TRANSFER_BYTES) => {
+    assertTransferByteBudget(transferBytes);
+    let bytes = 0;
+    let records = 0;
+    for (const record of moduleTransferRecords(module)) {
+        bytes += encodeTransferRecord(record, bytes, transferBytes).size;
+        records += 1;
+    }
+    return {
+        bytes,
+        records,
+        retentionBytes: javaScriptTransferRetentionBytes(bytes, records),
+    };
+};
+/** Encode validated facts in bounded records, without serializing a whole graph or IR. */
+export const writeJavaScriptAnalysisTransfer = async (path, module, projection, transferBytes = TRANSFER_BYTES) => {
+    assertTransferByteBudget(transferBytes);
+    const output = await open(path, "wx", 0o600);
+    const digest = createHash("sha256");
+    let bytes = 0;
+    let records = 0;
+    let moduleBytes = 0;
+    let moduleRecords = 0;
+    let graphBytes = 0;
+    let graphRecords = 0;
+    let batch = [];
+    let batchBytes = 0;
+    const flush = async () => {
+        if (batch.length === 0)
+            return;
+        const buffer = Buffer.from(batch.join(""));
+        // FileHandle.write can be short; writeFile completes the buffer.
+        await output.writeFile(buffer);
+        digest.update(buffer);
+        batch = [];
+        batchBytes = 0;
+    };
+    const append = async (input) => {
+        const { line, size, kind } = encodeTransferRecord(input, bytes, transferBytes);
+        bytes += size;
+        records += 1;
+        if (["module-header", "scope", "binding", "callable", "module-link"].includes(kind)) {
+            moduleBytes += size;
+            moduleRecords += 1;
+        }
+        else {
+            graphBytes += size;
+            graphRecords += 1;
+        }
+        batch.push(line);
+        batchBytes += size;
+        if (batchBytes >= BATCH_BYTES)
+            await flush();
+    };
+    try {
+        await append({
+            kind: "projection-header",
+            value: { roots: projection.roots, truncated: projection.truncated },
+        });
+        for (const record of moduleTransferRecords(module))
+            await append(record);
+        for (const value of projection.evidenceContexts)
+            await append({ kind: "evidence-context", value });
+        for (const value of projection.nodes)
+            await append({ kind: "node", value });
+        for (const value of projection.relations)
+            await append({ kind: "relation", value });
+        for (const value of projection.unknowns)
+            await append({ kind: "unknown", value });
+        for (const value of projection.fingerprints)
+            await append({ kind: "fingerprint", value });
+        await flush();
+        return {
+            bytes,
+            sha256: digest.digest("hex"),
+            records,
+            module_bytes: moduleBytes,
+            module_records: moduleRecords,
+            graph_bytes: graphBytes,
+            graph_records: graphRecords,
+        };
+    }
+    finally {
+        await output.close();
+    }
+};
+export async function readJavaScriptAnalysisTransfer(path, descriptor, source, signal, retainGraph = true) {
+    const expected = javaScriptAnalysisTransferDescriptorSchema.parse(descriptor);
+    if ((await stat(path)).size !== expected.bytes)
+        throw new TypeError("JavaScript analysis transfer byte count does not match");
+    const scopes = [];
+    const bindings = [];
+    const callables = [];
+    const moduleLinks = [];
+    const evidenceContexts = [];
+    const nodes = [];
+    const relations = [];
+    const unknowns = [];
+    const fingerprints = [];
+    let projectionHeader;
+    let moduleHeader;
+    const identities = new Map();
+    const retainIdentity = (kind, identifier) => {
+        let seen = identities.get(kind);
+        if (seen === undefined) {
+            seen = new Set();
+            identities.set(kind, seen);
+        }
+        if (seen.has(identifier))
+            throw new TypeError(`Duplicate JavaScript transfer ${kind} identity: ${identifier}`);
+        seen.add(identifier);
+    };
+    let records = 0;
+    let moduleBytes = 0;
+    let moduleRecords = 0;
+    let graphBytes = 0;
+    let graphRecords = 0;
+    const digest = createHash("sha256");
+    const stream = createReadStream(path, {
+        highWaterMark: 64 * 1024,
+        ...(signal === undefined ? {} : { signal }),
+    });
+    let bytes = 0;
+    let pending = "";
+    stream.setEncoding("utf8");
+    try {
+        for await (const chunk of stream) {
+            signal?.throwIfAborted();
+            if (typeof chunk !== "string")
+                throw new TypeError("JavaScript transfer stream is not UTF-8 text");
+            bytes += Buffer.byteLength(chunk);
+            if (bytes > expected.bytes)
+                throw new RangeError("JavaScript transfer grew while being read");
+            digest.update(chunk);
+            pending += chunk;
+            let newline;
+            while ((newline = pending.indexOf("\n")) >= 0) {
+                const line = pending.slice(0, newline);
+                pending = pending.slice(newline + 1);
+                if (Buffer.byteLength(line) + 1 > FRAME_BYTES)
+                    throw new RangeError("JavaScript transfer record exceeds its byte budget");
+                const input = JSON.parse(line);
+                const record = recordSchema.parse(input);
+                if ([
+                    "module-header",
+                    "scope",
+                    "binding",
+                    "callable",
+                    "module-link",
+                ].includes(record.kind)) {
+                    moduleBytes += Buffer.byteLength(line) + 1;
+                    moduleRecords += 1;
+                }
+                else {
+                    graphBytes += Buffer.byteLength(line) + 1;
+                    graphRecords += 1;
+                }
+                if (record.kind === "projection-header") {
+                    if (records !== 0 || projectionHeader !== undefined)
+                        throw new TypeError("Duplicate or late JavaScript projection header");
+                    projectionHeader = record.value;
+                }
+                else if (record.kind === "module-header") {
+                    if (records !== 1 || moduleHeader !== undefined)
+                        throw new TypeError("Duplicate or late JavaScript module header");
+                    moduleHeader = record.value;
+                }
+                else {
+                    if (projectionHeader === undefined || moduleHeader === undefined)
+                        throw new TypeError("JavaScript transfer facts precede their headers");
+                    if (!retainGraph &&
+                        [
+                            "evidence-context",
+                            "node",
+                            "relation",
+                            "unknown",
+                            "fingerprint",
+                        ].includes(record.kind)) {
+                        if (record.kind === "node" &&
+                            (record.value.identity.artifact_sha256 !== source.sha256 ||
+                                record.value.identity.module_path !== source.path))
+                            throw new TypeError("JavaScript transfer node belongs to a different artifact source");
+                        records += 1;
+                        continue;
+                    }
+                    switch (record.kind) {
+                        case "scope":
+                            retainIdentity(record.kind, record.value.scopeId);
+                            scopes.push(record.value);
+                            break;
+                        case "binding":
+                            retainIdentity(record.kind, record.value.bindingId);
+                            bindings.push(record.value);
+                            break;
+                        case "callable":
+                            retainIdentity(record.kind, record.value.callableId);
+                            callables.push(record.value);
+                            break;
+                        case "module-link":
+                            moduleLinks.push(record.value);
+                            break;
+                        case "evidence-context":
+                            retainIdentity(record.kind, record.value.context_id);
+                            evidenceContexts.push(record.value);
+                            break;
+                        case "node": {
+                            retainIdentity(record.kind, record.value.node_id);
+                            if (record.value.identity.artifact_sha256 !== source.sha256 ||
+                                record.value.identity.module_path !== source.path)
+                                throw new TypeError("JavaScript transfer node belongs to a different artifact source");
+                            nodes.push(record.value);
+                            break;
+                        }
+                        case "relation":
+                            retainIdentity(record.kind, record.value.relation_id);
+                            relations.push(record.value);
+                            break;
+                        case "unknown":
+                            retainIdentity(record.kind, record.value.unknown_id);
+                            unknowns.push(record.value);
+                            break;
+                        case "fingerprint":
+                            retainIdentity(record.kind, record.value.fingerprint_id);
+                            fingerprints.push(record.value);
+                            break;
+                    }
+                }
+                records += 1;
+            }
+            if (Buffer.byteLength(pending) + 1 > FRAME_BYTES)
+                throw new RangeError("Unterminated JavaScript transfer record exceeds its byte budget");
+        }
+    }
+    finally {
+        stream.destroy();
+    }
+    if (pending !== "" ||
+        records !== expected.records ||
+        bytes !== expected.bytes ||
+        moduleBytes !== expected.module_bytes ||
+        moduleRecords !== expected.module_records ||
+        graphBytes !== expected.graph_bytes ||
+        graphRecords !== expected.graph_records ||
+        digest.digest("hex") !== expected.sha256)
+        throw new TypeError("JavaScript analysis transfer is incomplete or its digest does not match");
+    if (projectionHeader === undefined || moduleHeader === undefined)
+        throw new TypeError("JavaScript analysis transfer is missing its headers");
+    return {
+        module: { ...moduleHeader, scopes, bindings, callables, moduleLinks },
+        projection: retainGraph
+            ? {
+                ...projectionHeader,
+                evidenceContexts,
+                nodes,
+                relations,
+                unknowns,
+                fingerprints,
+            }
+            : null,
+    };
+}