rea-agents 6.3.0 → 6.5.0

package/dist/javascript/recovery/WakaruPublication.js

@@ -2,25 +2,33 @@ import { join } from "node:path";
 import { Readable } from "node:stream";
 import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
 import { javascriptRecoveryResultSchema, } from "../../domain/javascript/javascriptRecovery.js";
-import { readRecoveryFile, recoveryDigest } from "./RecoveryFiles.js";
+import { readRecoveryFile, recoveryDigest, } from "./RecoveryFiles.js";
 import { recoveryRanges, validateRecoverySourceMap, } from "./WakaruReport.js";
 import { RECOVERY_LIMITATIONS, RECOVERY_LIMITS, WAKARU_RELEASE, } from "./WakaruRelease.js";
 /** Write validated artifacts to one exclusively owned, rollback-capable tree. */
 export const publishWakaruArtifacts = async (context) => {
-    const { tree, source, parsed, staging, signal } = context;
+    const { tree, sources, parsed, staging, signal } = context;
     const write = async (path, bytes) => {
         const sha256 = recoveryDigest(bytes);
-        const file = await tree.write(path, Readable.from([bytes]), sha256, signal);
+        const file = await tree.write(path, Readable.from([bytes]), { sha256, bytes: bytes.byteLength }, signal);
         return {
             path: join(tree.outputRoot, file.relativePath),
             sha256: file.sha256,
             bytes: file.bytesWritten,
         };
     };
-    const snapshot = await readRecoveryFile(source.snapshot_path, RECOVERY_LIMITS.inputBytes, signal);
-    if (recoveryDigest(snapshot) !== source.sha256)
-        throw new AnalysisOutputError("recover_javascript_sources", "The input snapshot changed during recovery");
-    const publishedCopy = await write("inputs/bundle.js", snapshot);
+    const publishedSources = [];
+    for (const selected of sources) {
+        const { relative_path, ...source } = selected;
+        const snapshot = await readRecoveryFile(source.snapshot_path, source.bytes, signal);
+        if (recoveryDigest(snapshot) !== source.sha256)
+            throw new AnalysisOutputError("recover_javascript_sources", `The input snapshot changed during recovery: ${source.path}`);
+        publishedSources.push({
+            ...source,
+            published_copy: await write(`inputs/${relative_path}`, snapshot),
+        });
+    }
+    const [source, ...additionalSources] = publishedSources;
     const modules = [];
     for (const module of parsed.report.modules) {
         modules.push(await publishModule(context, module, write));
@@ -28,10 +36,13 @@ export const publishWakaruArtifacts = async (context) => {
     const report = await write("reports/stdout.json", Buffer.from(context.execution.stdout));
     const provenance = await write("reports/provenance.json", await readRecoveryFile(join(staging, "provenance.json"), RECOVERY_LIMITS.reportBytes, signal));
     const details = {
-        source: { ...source, published_copy: publishedCopy },
+        source,
+        ...(additionalSources.length === 0
+            ? {}
+            : { additional_sources: additionalSources }),
         engine: {
             id: "wakaru",
-            version: WAKARU_RELEASE.version,
+            version: context.admitted.version,
             executable: {
                 path: context.engine.command,
                 sha256: context.engine.sha256,
@@ -52,7 +63,12 @@ export const publishWakaruArtifacts = async (context) => {
         total: parsed.report.total,
         failed: parsed.report.failed,
         modules,
-        warnings: parsed.report.warnings,
+        warnings: parsed.report.warnings.map(({ filename, kind, is_error, message }) => ({
+            filename,
+            kind,
+            is_error,
+            message,
+        })),
         report,
         provenance,
         analysis_input: modules.length === 0
@@ -62,13 +78,18 @@ export const publishWakaruArtifacts = async (context) => {
                 format: "directory",
             },
         runtime_equivalence: "unknown",
-        limitations: [...RECOVERY_LIMITATIONS],
+        limitations: [
+            ...RECOVERY_LIMITATIONS,
+            ...(context.admitted.status === "compatible"
+                ? [context.admitted.limitation]
+                : []),
+        ],
     };
     const manifest = await write("manifest.json", Buffer.from(`${JSON.stringify(details, null, 2)}\n`));
     return javascriptRecoveryResultSchema.parse({ ...details, manifest });
 };
 const publishModule = async (context, module, write) => {
-    const { staging, source, parsed, signal } = context;
+    const { staging, sources, parsed, signal } = context;
     const artifact = await write(`modules/${module.filename}`, await readRecoveryFile(join(staging, module.filename), RECOVERY_LIMITS.outputBytes, signal));
     const mapPath = join(staging, `${module.filename}.map`);
     let sourceMap = null;
@@ -84,6 +105,9 @@ const publishModule = async (context, module, write) => {
     const provenance = parsed.provenance.modules[module.filename];
     if (provenance === undefined)
         throw new AnalysisOutputError("recover_javascript_sources", `Missing module provenance: ${module.filename}`);
+    const origin = sources.find((source) => source.snapshot_path === provenance.input);
+    if (origin === undefined)
+        throw new AnalysisOutputError("recover_javascript_sources", `Unselected module provenance input: ${provenance.input}`);
     return {
         reported_filename: module.filename,
         reported_status: module.status,
@@ -91,8 +115,8 @@ const publishModule = async (context, module, write) => {
         source_map: sourceMap,
         provenance: {
             reported_input: provenance.input,
-            original_path: source.path,
-            original_sha256: source.sha256,
+            original_path: origin.path,
+            original_sha256: origin.sha256,
             extraction: provenance.extraction,
             byte_ranges: recoveryRanges(provenance.ranges),
             context_byte_ranges: recoveryRanges(provenance.context_ranges ?? []),

package/dist/javascript/recovery/WakaruRelease.js

@@ -1,10 +1,17 @@
 /** Unchanged upstream source pin; executed bytes are identified separately. */
 export const WAKARU_RELEASE = {
-    version: "1.13.0",
-    revision: "6070266d24b32951fa2fe1d2dad5b4313bd5c81b",
+    version: "1.14.0",
+    revision: "8219bf5016a063d7fb215101a8c45d5959ec733f",
     repository: "https://github.com/pionxzh/wakaru",
 };
-/** Exact provider identity shared by executions and the generated catalog. */
+/**
+ * Releases the report parser accepts. Wakaru changes `--version`, `--json`
+ * and `provenance.json` only by addition within a major version
+ * (https://github.com/pionxzh/wakaru/blob/v1.14.0/docs/cli.md#machine-readable-output-compatibility);
+ * 1.13.0 is the first release this adapter verified.
+ */
+export const WAKARU_ACCEPTED_RANGE = "^1.13.0";
+/** Catalog identity for the verified Wakaru release. Evidence replaces version with the observed banner. */
 export const WAKARU_PROVIDER_IDENTITY = {
     id: "wakaru",
     name: "Wakaru",
@@ -25,5 +32,5 @@ export const RECOVERY_LIMITATIONS = [
     "Extraction ranges refer to half-open UTF-8 byte offsets in the original input, not rewritten line positions or whole-bundle coverage.",
     "Emitted source maps are preserved as reported by the engine; their mapping accuracy is not independently established.",
     "Inspection mode may produce non-executable regions. No input or recovered application code is executed.",
-    "Linux adapter: one worker, 1 GiB address-space ceiling, 120-second deadline, 64 MiB input, 128 MiB output, 10000 output entries and 8 MiB per diagnostic/report stream. Resource limits are per operation, not aggregate host containment.",
+    "Linux adapter: one worker, 1 GiB address-space ceiling, 120-second deadline, 64 MiB total input, 128 MiB output, 10000 output entries and 8 MiB per diagnostic/report stream. Resource limits are per operation, not aggregate host containment.",
 ];

package/dist/javascript/recovery/WakaruReport.js

@@ -4,19 +4,19 @@ import { AnalysisOutputError } from "../../domain/analysisErrorCore.js";
 import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
 import { readRecoveryFile, recoveryFailureMessage } from "./RecoveryFiles.js";
 import { RECOVERY_LIMITS } from "./WakaruRelease.js";
-const warningSchema = z.strictObject({
+const warningSchema = z.looseObject({
     filename: z.string(),
     kind: z.string(),
     is_error: z.boolean(),
     message: z.string(),
 });
-const reportSchema = z.strictObject({
+const reportSchema = z.looseObject({
     detected_formats: z.array(z.string()),
     safety: z.string(),
-    modules: z.array(z.strictObject({
+    modules: z.array(z.looseObject({
         filename: z.string().min(1),
         kind: z.literal("javascript"),
-        status: z.literal("decompiled"),
+        status: z.string().min(1),
     })),
     warnings: z.array(warningSchema),
     total: z.number().int().nonnegative(),
@@ -27,10 +27,10 @@ const rangeSchema = z.tuple([
     z.number().int().nonnegative(),
     z.number().int().nonnegative(),
 ]);
-const provenanceSchema = z.strictObject({
+const provenanceSchema = z.looseObject({
     format: z.string(),
     strategy: z.string(),
-    modules: z.record(z.string(), z.strictObject({
+    modules: z.record(z.string(), z.looseObject({
         input: z.string(),
         ranges: z.array(rangeSchema),
         extraction: z.string(),
@@ -38,7 +38,12 @@ const provenanceSchema = z.strictObject({
     })),
 });
 const OPERATION = "recover_javascript_sources";
-/** Parse exact pinned producer JSON before projecting provider-neutral artifacts. */
+/**
+ * Parse producer JSON before projecting provider-neutral artifacts. Wakaru adds
+ * fields and category values within a major version, so unknown keys are kept
+ * and `status` stays the reported string; identity, path, range and file-set
+ * checks below remain exact.
+ */
 export const parseWakaruReports = async (context) => {
     const { execution, provenancePath } = context;
     try {
@@ -77,7 +82,7 @@ export const parseWakaruReports = async (context) => {
     }
 };
 const validateModuleSet = (report, provenance, context) => {
-    const { files, snapshotPath, sourceBytes } = context;
+    const { files, snapshots } = context;
     const registry = new ArtifactPathRegistry();
     const expected = new Set(["provenance.json"]);
     const observed = new Set(files.map((file) => file.relativePath));
@@ -92,7 +97,8 @@ const validateModuleSet = (report, provenance, context) => {
         if (observed.has(`${path}.map`))
             expected.add(`${path}.map`);
         const entry = provenance.modules[path];
-        if (entry === undefined || entry.input !== snapshotPath)
+        const sourceBytes = entry === undefined ? undefined : snapshots.get(entry.input);
+        if (entry === undefined || sourceBytes === undefined)
             throw new TypeError(`Module provenance does not bind the selected input snapshot: ${path}`);
         validateRanges([...entry.ranges, ...(entry.context_ranges ?? [])], sourceBytes, path);
     }

package/dist/javascript/recovery/WakaruVersion.js

@@ -0,0 +1,24 @@
+import { satisfies, valid } from "semver";
+import { WAKARU_ACCEPTED_RANGE, WAKARU_RELEASE } from "./WakaruRelease.js";
+/** Caller-facing accepted releases, naming the verified build. */
+export const wakaruReleaseLine = () => `Wakaru ${WAKARU_ACCEPTED_RANGE} (verified with ${WAKARU_RELEASE.version})`;
+/** Classify a `wakaru <version>` banner against the accepted release range. */
+export const admitWakaruVersion = (banner) => {
+    const token = banner.startsWith("wakaru ")
+        ? banner.slice("wakaru ".length)
+        : undefined;
+    if (token === undefined ||
+        valid(token) !== token ||
+        !satisfies(token, WAKARU_ACCEPTED_RANGE))
+        return {
+            status: "unsupported",
+            message: `Unsupported Wakaru version ${banner.length === 0 ? "missing" : banner}; accepted releases are ${wakaruReleaseLine()}`,
+        };
+    if (token === WAKARU_RELEASE.version)
+        return { status: "verified", version: token };
+    return {
+        status: "compatible",
+        version: token,
+        limitation: `This session uses Wakaru ${token}. The report parser is verified against ${WAKARU_RELEASE.version}; other ${WAKARU_ACCEPTED_RANGE} releases are accepted and the observed version is reported.`,
+    };
+};

package/dist/javascript/sourceMaps/DecodedSourceMap.js

@@ -9,24 +9,10 @@ export const isBeforeSourceMapLeafStop = (leaf, line, column) => {
     return (generatedLine < leaf.stop.line ||
         (generatedLine === leaf.stop.line && generatedColumn < leaf.stop.column));
 };
-/** Resolve one declaration with the same pinned upstream implementation used by full maps. */
-export const resolveSourceMapSource = (source, sourceRoot, mapUrl) => {
-    const map = new TraceMap({
-        version: 3,
-        names: [],
-        sources: [source ?? ""],
-        ...(sourceRoot == null ? {} : { sourceRoot }),
-        mappings: "",
-    }, mapUrl);
-    const resolved = map.resolvedSources[0];
-    if (resolved === undefined)
-        throw new SourceMapFormatFailure("format", "Source-map resolver did not return the requested source identity.");
-    return resolved;
-};
 /** Decode leaf mappings and validate producer indices before any consumer publishes them. */
 export const decodeValidatedSourceMapLeaves = (leaves, mapUrl, check) => leaves.map((leaf) => {
     check?.();
-    const map = new TraceMap(JSON.stringify(leaf.map), mapUrl);
+    const map = new TraceMap(leaf.codecMap, mapUrl);
     const rows = decodedMappings(map);
     for (const [line, row] of rows.entries()) {
         if ((line & 255) === 0)
@@ -43,5 +29,5 @@ export const decodeValidatedSourceMapLeaves = (leaves, mapUrl, check) => leaves.
                 throw new SourceMapFormatFailure("format", "Decoded local or absolute position, source index or name index is invalid.");
         }
     }
-    return { leaf, rows, resolvedSources: map.resolvedSources };
+    return { leaf, map, rows, resolvedSources: map.resolvedSources };
 });

package/dist/javascript/sourceMaps/SourceMapCommand.js

@@ -3,18 +3,29 @@ import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { AnalysisError } from "../../domain/analysisErrorBase.js";
-import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisOutputError, AnalysisTimeoutError, } from "../../domain/analysisErrorCore.js";
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisOutputError, AnalysisResourceConstraintError, AnalysisTimeoutError, } from "../../domain/analysisErrorCore.js";
 import { ProviderAdapterError } from "../../domain/providerAdapterError.js";
 import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
 import { err, ok } from "../../domain/result.js";
 import { WEB_SOURCE_MAP_LIMITS } from "../../domain/webSourceLocation.js";
-import { PrivateRuntimeRoot, PrivateRuntimeRootUnavailableError, } from "../../process/PrivateRuntimeRoot.js";
+import { PrivateRuntimeRoot } from "../../process/PrivateRuntimeRoot.js";
+import { PrivateRuntimeRootUnavailableError } from "../../process/PrivateRuntimeRootUnavailableError.js";
 import { ProviderStartupDeadline } from "../../process/ProviderDeadline.js";
+import { javaScriptWorkerMemoryLimitBytes } from "../../process/JavaScriptWorkerMemoryLimit.js";
 import { cleanupOwnedProcessGroup } from "../../process/ProcessOwnership.js";
 import { ProviderProcessSupervisor, spawnOwnedProviderProcess, } from "../../process/ProviderProcess.js";
 import { prepareProcessOwnershipInspection } from "../../process/ProcessOwnershipObservation.js";
 const OPERATION = "trace_web_source_location";
 const PROVIDER = "source-map-decoder";
+/** Process commit limit enforced on the codec; null where V8 heap flags apply. */
+export const SOURCE_MAP_CODEC_MEMORY_LIMIT_BYTES = javaScriptWorkerMemoryLimitBytes(WEB_SOURCE_MAP_LIMITS.codecHeapMiB);
+export class SourceMapCleanupFailure extends ProviderCleanupError {
+    cleanupOwner;
+    constructor(cleanupOwner, resources, diagnostics) {
+        super(PROVIDER, resources, diagnostics, { operation: OPERATION });
+        this.cleanupOwner = cleanupOwner;
+    }
+}
 /** Run a trusted codec command and release its process/root before returning output. */
 export const runSourceMapCommand = async (request, path, options, dependencies) => {
     try {
@@ -86,7 +97,7 @@ class OwnedCodec {
         const spawned = await (this.dependencies.launcher ?? spawnOwnedProviderProcess)({
             command: process.execPath,
             arguments: [
-                "--max-old-space-size=192",
+                `--max-old-space-size=${String(WEB_SOURCE_MAP_LIMITS.codecHeapMiB)}`,
                 "--max-semi-space-size=8",
                 "--v8-pool-size=1",
                 "--single-threaded",
@@ -97,6 +108,9 @@ class OwnedCodec {
             runId: this.#runId,
             cwd: this.#runtime.path,
             hostEnvironment: environment,
+            ...(SOURCE_MAP_CODEC_MEMORY_LIMIT_BYTES === null
+                ? {}
+                : { memoryLimitBytes: SOURCE_MAP_CODEC_MEMORY_LIMIT_BYTES }),
             signal: this.deadline.signal,
         });
         this.#supervisor = new ProviderProcessSupervisor({
@@ -125,6 +139,17 @@ class OwnedCodec {
             this.check();
         this.check();
         const snapshot = supervisor.snapshot();
+        // No partial codec result exists; a reached limit fails the whole trace.
+        if (snapshot.memoryLimitReached === true)
+            throw new AnalysisResourceConstraintError(OPERATION, "memory", `Source-map codec reached its ${SOURCE_MAP_CODEC_MEMORY_LIMIT_BYTES === null ? "" : `${String(SOURCE_MAP_CODEC_MEMORY_LIMIT_BYTES)}-byte `}process memory limit for ${this.path}; no partial evidence was returned.`, {
+                codec_process_memory_limit_bytes: SOURCE_MAP_CODEC_MEMORY_LIMIT_BYTES,
+            }, {
+                capturedOutput: {
+                    stdout: "",
+                    stderr: snapshot.stderr.text,
+                    truncated: snapshot.diagnosticTruncated ?? false,
+                },
+            });
         if (snapshot.exitCode !== 0 || snapshot.signal !== null)
             throw new ProviderAdapterError(PROVIDER, OPERATION, {
                 diagnostics: {
@@ -156,7 +181,7 @@ class OwnedCodec {
         if (cause instanceof AnalysisError)
             return cause;
         return cause instanceof PrivateRuntimeRootUnavailableError
-            ? new AnalysisCapabilityUnavailableError(PROVIDER, OPERATION, cause.message, { cause })
+            ? new AnalysisCapabilityUnavailableError(PROVIDER, OPERATION, cause.message, { cause, retryable: cause.retryable })
             : new ProviderAdapterError(PROVIDER, OPERATION, {
                 cause,
                 diagnostics: { map_path: this.path, error_message: message(cause) },
@@ -164,14 +189,20 @@ class OwnedCodec {
     }
     async close(previousError) {
         const failures = [];
+        let processReleased = this.#supervisor === undefined;
         if (this.#supervisor !== undefined) {
             const stopped = await this.#supervisor.stop();
             if (stopped.status === "incomplete")
                 failures.push(stopped.reason);
+            else {
+                processReleased = true;
+                this.#supervisor = undefined;
+            }
         }
-        if (this.#runtime !== undefined) {
+        if (processReleased && this.#runtime !== undefined) {
             try {
                 await this.#runtime.close();
+                this.#runtime = undefined;
             }
             catch (cause) {
                 failures.push(message(cause));
@@ -179,7 +210,7 @@ class OwnedCodec {
         }
         return failures.length === 0
             ? undefined
-            : new ProviderCleanupError(PROVIDER, [
+            : new SourceMapCleanupFailure(this, [
                 this.#runId,
                 ...(this.#runtime === undefined ? [] : [this.#runtime.path]),
             ], {
@@ -187,7 +218,7 @@ class OwnedCodec {
                 cleanup_failures: failures,
                 previous_error: previousError,
                 codec_pid: this.#supervisor?.launch.process.pid ?? null,
-            }, { operation: OPERATION });
+            });
     }
 }
 const message = (cause) => cause instanceof Error ? cause.message : String(cause);

package/dist/javascript/sourceMaps/SourceMapDecoder.js

@@ -1,18 +1,37 @@
 import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
 import { ArtifactOperationError } from "../../domain/artifactOperationError.js";
 import { err, ok } from "../../domain/result.js";
+import { javaScriptRuntime } from "../../domain/runtimeVersion.js";
 import { WEB_SOURCE_MAP_LIMITS, } from "../../domain/webSourceLocation.js";
 import { sourceMapCodecInputSchema, sourceMapCodecReplySchema, } from "./SourceMapCodecProtocol.js";
-import { runSourceMapCommand, } from "./SourceMapCommand.js";
+import { SOURCE_MAP_CODEC_MEMORY_LIMIT_BYTES, SourceMapCleanupFailure, runSourceMapCommand, } from "./SourceMapCommand.js";
+import { ProviderCleanupError } from "../../domain/providerCleanupError.js";
+import { jsonParts } from "../../domain/jsonSerialization.js";
 const OPERATION = "trace_web_source_location";
 /** Integrate the pinned upstream codec through an independently bounded owned process. */
 export class SourceMapDecoder {
     dependencies;
+    #tail = Promise.resolve();
+    #closing = false;
+    #closePromise;
+    #pendingCleanup;
     constructor(dependencies = {}) {
         this.dependencies = dependencies;
     }
     /** Return complete point evidence after process and private-root cleanup. */
-    async trace(input, options) {
+    trace(input, options) {
+        if (this.#closing)
+            return Promise.resolve(err(new ProviderCleanupError("source-map-decoder", [], { reason: "Provider is closing" }, { operation: OPERATION })));
+        const operation = this.#tail.then(() => this.#closing
+            ? err(new ProviderCleanupError("source-map-decoder", [], { reason: "Provider is closing" }, { operation: OPERATION }))
+            : this.#trace(input, options));
+        this.#tail = operation.then(() => undefined, () => undefined);
+        return operation;
+    }
+    async #trace(input, options) {
+        const cleanupFailure = await this.#retryCleanup();
+        if (cleanupFailure !== undefined)
+            return err(cleanupFailure);
         if (options?.signal?.aborted)
             return err(new AnalysisCancelledError(OPERATION));
         const request = sourceMapCodecInputSchema.safeParse({
@@ -22,13 +41,27 @@ export class SourceMapDecoder {
         });
         if (!request.success)
             return err(new AnalysisInputError(OPERATION, { cause: request.error }));
-        const serialized = JSON.stringify(request.data);
-        if (Buffer.byteLength(input.text) > WEB_SOURCE_MAP_LIMITS.mapBytes ||
-            Buffer.byteLength(serialized) > WEB_SOURCE_MAP_LIMITS.outputBytes)
-            return err(new ArtifactOperationError(OPERATION, "limit", undefined, `${input.path}: Source-map input exceeds the 4 MiB map or 32 MiB encoded request budget.`));
+        const capacityFailure = () => new ArtifactOperationError(OPERATION, "limit", undefined, `${input.path}: Source-map input exceeds the 4 MiB map or 32 MiB encoded request budget.`);
+        if (Buffer.byteLength(input.text) > WEB_SOURCE_MAP_LIMITS.mapBytes)
+            return err(capacityFailure());
+        const encoded = [];
+        let encodedBytes = 0;
+        for (const part of jsonParts(request.data)) {
+            const bytes = Buffer.byteLength(part);
+            if (bytes > WEB_SOURCE_MAP_LIMITS.outputBytes - encodedBytes)
+                return err(capacityFailure());
+            encoded.push(part);
+            encodedBytes += bytes;
+        }
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION));
+        const serialized = encoded.join("");
         const response = await runSourceMapCommand(serialized, input.path, options, this.dependencies);
-        if (!response.ok)
+        if (!response.ok) {
+            if (response.error instanceof SourceMapCleanupFailure)
+                this.#pendingCleanup = response.error.cleanupOwner;
             return response;
+        }
         let value;
         try {
             value = JSON.parse(response.value);
@@ -43,11 +76,52 @@ export class SourceMapDecoder {
             return err(new AnalysisCancelledError(OPERATION));
         if (reply.data.state === "failure")
             return codecFailure(input.path, reply.data.reason, reply.data.message);
-        if (reply.data.report.runtime.v8_heap_limit_bytes > 256 * 1024 * 1024)
-            return err(new AnalysisOutputError(OPERATION, "Codec reported a V8 heap limit exceeding its independent process budget."));
-        return ok(reply.data.report);
+        const runtimeFailure = codecRuntimeFailure(reply.data.report.runtime);
+        return runtimeFailure === undefined
+            ? ok(reply.data.report)
+            : err(new AnalysisOutputError(OPERATION, runtimeFailure));
+    }
+    async close() {
+        this.#closing = true;
+        this.#closePromise ??= this.#tail
+            .then(async () => {
+            const failure = await this.#retryCleanup();
+            if (failure !== undefined)
+                throw failure;
+        })
+            .catch((cause) => {
+            this.#closePromise = undefined;
+            throw cause;
+        });
+        return this.#closePromise;
+    }
+    async #retryCleanup() {
+        const pending = this.#pendingCleanup;
+        if (pending === undefined)
+            return undefined;
+        const failure = await pending.close(null);
+        if (failure !== undefined)
+            return failure;
+        this.#pendingCleanup = undefined;
+        return undefined;
     }
 }
+/**
+ * The codec runs on this process's executable. Only a V8 report carries a heap
+ * limit; a Bun report must name the process limit its launcher enforced.
+ */
+const codecRuntimeFailure = (runtime) => {
+    if (runtime.id !==
+        (javaScriptRuntime(process.versions).id === "bun" ? "bun" : "node-v8"))
+        return `Codec reported runtime ${runtime.id}, not the runtime that launched it.`;
+    if (runtime.id === "node-v8" &&
+        runtime.v8_heap_limit_bytes > 256 * 1024 * 1024)
+        return "Codec reported a V8 heap limit exceeding its independent process budget.";
+    if (runtime.id === "bun" &&
+        runtime.process_memory_limit_bytes !== SOURCE_MAP_CODEC_MEMORY_LIMIT_BYTES)
+        return "Codec reported a process memory limit other than the one its launcher enforced.";
+    return undefined;
+};
 const codecFailure = (path, reason, detail) => err(reason === "limit"
     ? new ArtifactOperationError(OPERATION, "limit", undefined, `${path}: ${detail}`)
     : reason === "unsupported"

package/dist/javascript/sourceMaps/SourceMapFormat.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { WEB_SOURCE_MAP_LIMITS } from "../../domain/webSourceLocation.js";
-import { hasValidSourceMapContents } from "../../domain/sourceMapContents.js";
+import { sourceMapJsonText } from "../../domain/sourceMapEnvelope.js";
 const leafSchema = z.object({
     version: z.literal(3),
     file: z.string().nullable().optional(),
@@ -37,6 +37,19 @@ export class SourceMapFormatFailure extends Error {
         this.reason = reason;
     }
 }
+const codecLeaf = (map) => ({
+    version: 3,
+    ...(map.file === undefined ? {} : { file: map.file }),
+    ...(typeof map.sourceRoot === "string" ? { sourceRoot: map.sourceRoot } : {}),
+    sources: map.sources,
+    ...(map.sourcesContent == null ? {} : { sourcesContent: map.sourcesContent }),
+    names: map.names,
+    mappings: map.mappings,
+    ...(map.ignoreList === undefined ? {} : { ignoreList: map.ignoreList }),
+    ...(map.x_google_ignoreList === undefined
+        ? {}
+        : { x_google_ignoreList: map.x_google_ignoreList }),
+});
 const compare = (a, b) => a.line - b.line || a.column - b.column;
 const addOffset = (base, offset) => {
     const result = {
@@ -154,12 +167,6 @@ const inspectLeaf = (node, budget, options) => {
     consumeRecords(budget, Array.isArray(rawNames) ? rawNames.length : 0);
     consumeRecords(budget, Array.isArray(rawContents) ? rawContents.length : 0);
     options.check?.();
-    if (options.profile === "browser-collection" && !Array.isArray(rawNames))
-        throw new SourceMapFormatFailure("format", "Source-map leaf requires a names array.");
-    if (options.profile === "browser-collection" &&
-        !hasValidSourceMapContents(Array.isArray(rawSources) ? rawSources.length : 0, rawContents))
-        throw new SourceMapFormatFailure("format", "Source-map sourcesContent must align with its source declarations.");
-    options.check?.();
     const leaf = leafSchema.parse(node.value);
     const layout = inspectMappingLayout(leaf.mappings, options.check);
     consumeRecords(budget, layout.segments + layout.lines);
@@ -170,25 +177,9 @@ const inspectLeaf = (node, budget, options) => {
 };
 /** Validate structure before allocation, retaining raw declarations and section boundaries. */
 export const inspectSourceMap = (text) => {
-    const withoutBom = text.replace(/^\uFEFF/u, "");
-    const jsonText = withoutBom.startsWith(")]}'")
-        ? withoutBom.slice(withoutBom.indexOf("\n") + 1)
-        : withoutBom;
+    const jsonText = sourceMapJsonText(text);
     const value = JSON.parse(jsonText);
-    const inspected = inspectSourceMapValue(value);
-    const normalized = inspected.format === "regular"
-        ? inspected.leaves[0]?.map
-        : {
-            version: 3,
-            sections: inspected.leaves.map((leaf) => ({
-                offset: leaf.offset,
-                map: leaf.map,
-            })),
-        };
-    return {
-        jsonText: JSON.stringify(normalized),
-        ...inspected,
-    };
+    return inspectSourceMapValue(value);
 };
 /** Return validated leaves when a consumer needs decoded rows after preflight. */
 export const inspectSourceMapValue = (value, options = {}) => {
@@ -212,8 +203,14 @@ export const inspectSourceMapValue = (value, options = {}) => {
             continue;
         }
         const leaf = inspectLeaf(node, budget, options);
-        leaves.push({ map: leaf, offset: node.offset, stop: node.stop });
-        if (options.profile !== "browser-collection")
+        leaves.push({
+            map: leaf,
+            codecMap: codecLeaf(leaf),
+            offset: node.offset,
+            stop: node.stop,
+        });
+        if (options.profile !== "browser-collection") {
+            const ignoredSources = new Set(leaf.ignoreList ?? leaf.x_google_ignoreList ?? []);
             for (const [sourceIndex, source] of leaf.sources.entries())
                 declarations.push({
                     sectionPath: node.path,
@@ -221,8 +218,9 @@ export const inspectSourceMapValue = (value, options = {}) => {
                     source,
                     root: leaf.sourceRoot ?? null,
                     content: leaf.sourcesContent?.[sourceIndex] ?? null,
-                    ignored: (leaf.ignoreList ?? leaf.x_google_ignoreList ?? []).includes(sourceIndex),
+                    ignored: ignoredSources.has(sourceIndex),
                 });
+        }
     }
     return {
         format: root.sections === undefined ? "regular" : "indexed",