rea-agents 4.0.1 → 5.0.0

package/dist/javascript/recovery/WakaruReport.js

@@ -0,0 +1,134 @@
+import { z } from "zod";
+import { normalizeArtifactPath, ArtifactPathRegistry, } from "../../artifacts/ArtifactPaths.js";
+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({
+    filename: z.string(),
+    kind: z.string(),
+    is_error: z.boolean(),
+    message: z.string(),
+});
+const reportSchema = z.strictObject({
+    detected_formats: z.array(z.string()),
+    safety: z.string(),
+    modules: z.array(z.strictObject({
+        filename: z.string().min(1),
+        kind: z.literal("javascript"),
+        status: z.literal("decompiled"),
+    })),
+    warnings: z.array(warningSchema),
+    total: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+    elapsed_ms: z.number().int().nonnegative(),
+});
+const rangeSchema = z.tuple([
+    z.number().int().nonnegative(),
+    z.number().int().nonnegative(),
+]);
+const provenanceSchema = z.strictObject({
+    format: z.string(),
+    strategy: z.string(),
+    modules: z.record(z.string(), z.strictObject({
+        input: z.string(),
+        ranges: z.array(rangeSchema),
+        extraction: z.string(),
+        context_ranges: z.array(rangeSchema).optional(),
+    })),
+});
+const OPERATION = "recover_javascript_sources";
+/** Parse exact pinned producer JSON before projecting provider-neutral artifacts. */
+export const parseWakaruReports = async (context) => {
+    const { execution, provenancePath } = context;
+    try {
+        if (execution.exit_code !== 0 && execution.exit_code !== 1)
+            throw new TypeError("Wakaru did not complete recovery (expected exit 0 or a reported partial exit 1)");
+        const report = reportSchema.parse(JSON.parse(execution.stdout));
+        const provenance = provenanceSchema.parse(JSON.parse((await readRecoveryFile(provenancePath, RECOVERY_LIMITS.reportBytes)).toString("utf8")));
+        if (report.total !== report.modules.length || report.failed > report.total)
+            throw new TypeError("Reported module totals disagree");
+        if (execution.exit_code === 1 &&
+            report.failed === 0 &&
+            !report.warnings.some((warning) => warning.is_error))
+            throw new TypeError("Wakaru exited 1 without a reported partial recovery reason");
+        validateModuleSet(report, provenance, context);
+        return {
+            report,
+            provenance,
+            status: report.failed > 0 ||
+                report.warnings.some((warning) => warning.is_error) ||
+                execution.exit_code === 1
+                ? "partial"
+                : "complete",
+        };
+    }
+    catch (cause) {
+        throw new ProviderAdapterError("wakaru", OPERATION, {
+            cause,
+            diagnostics: {
+                reason: `Unusable Wakaru recovery report: ${recoveryFailureMessage(cause)}`,
+                exit_code: execution.exit_code,
+                signal: execution.signal,
+                stdout: execution.stdout,
+                stderr: execution.stderr,
+            },
+        });
+    }
+};
+const validateModuleSet = (report, provenance, context) => {
+    const { files, snapshotPath, sourceBytes } = context;
+    const registry = new ArtifactPathRegistry();
+    const expected = new Set(["provenance.json"]);
+    const observed = new Set(files.map((file) => file.relativePath));
+    for (const module of report.modules) {
+        const path = normalizeArtifactPath(module.filename);
+        if (path !== module.filename || !/\.(?:js|mjs|cjs)$/u.test(path))
+            throw new TypeError(`Unsupported module path: ${module.filename}`);
+        registry.add(path, "file");
+        if (!observed.has(path))
+            throw new TypeError(`Missing reported module file: ${path}`);
+        expected.add(path);
+        if (observed.has(`${path}.map`))
+            expected.add(`${path}.map`);
+        const entry = provenance.modules[path];
+        if (entry === undefined || entry.input !== snapshotPath)
+            throw new TypeError(`Module provenance does not bind the selected input snapshot: ${path}`);
+        validateRanges([...entry.ranges, ...(entry.context_ranges ?? [])], sourceBytes, path);
+    }
+    if (Object.keys(provenance.modules).length !== report.modules.length)
+        throw new TypeError("Provenance and reported module sets disagree");
+    for (const path of observed)
+        if (!expected.has(path))
+            throw new TypeError(`Unreported recovery artifact: ${path}`);
+};
+const validateRanges = (ranges, bytes, filename) => {
+    for (const [start, end] of ranges) {
+        if (start > end ||
+            end > bytes.length ||
+            !utf8Boundary(bytes, start) ||
+            !utf8Boundary(bytes, end))
+            throw new TypeError(`Invalid half-open UTF-8 byte range [${String(start)},${String(end)}) for ${filename}`);
+    }
+};
+const utf8Boundary = (bytes, offset) => {
+    const value = bytes[offset];
+    return value === undefined || (value & 0xc0) !== 0x80;
+};
+/** Translate extraction byte ranges without claiming rewritten line positions. */
+export const recoveryRanges = (ranges) => ranges.map(([start, end]) => ({ start, end }));
+/** Validate a source map's representation; preserve its unverified mapping bytes. */
+export const validateRecoverySourceMap = (bytes, filename) => {
+    const schema = z.object({
+        version: z.literal(3),
+        sources: z.array(z.string()),
+        names: z.array(z.string()),
+        mappings: z.string(),
+    });
+    try {
+        schema.parse(JSON.parse(bytes.toString("utf8")));
+    }
+    catch (cause) {
+        throw new AnalysisOutputError(OPERATION, `Invalid emitted source map for ${filename}: ${recoveryFailureMessage(cause)}`, { cause });
+    }
+};

package/dist/javascript/sourceMaps/SourceMapCodecProcess.js

@@ -0,0 +1,37 @@
+import { readStableArtifact } from "../../artifacts/readStableArtifact.js";
+import { WEB_SOURCE_MAP_LIMITS } from "../../domain/webSourceLocation.js";
+import { traceSourceMap } from "./TraceSourceMap.js";
+import { SourceMapFormatFailure } from "./SourceMapFormat.js";
+import { sourceMapCodecInputSchema, sourceMapCodecReplySchema, } from "./SourceMapCodecProtocol.js";
+import { z } from "zod";
+/** Dedicated process entrypoint invoked only for an explicitly selected map. */
+const execute = async () => {
+    try {
+        const path = process.argv[2];
+        if (path === undefined)
+            throw new SourceMapFormatFailure("format", "Codec request path is missing.");
+        const data = await readStableArtifact(path, WEB_SOURCE_MAP_LIMITS.outputBytes);
+        const text = new TextDecoder("utf-8", { fatal: true }).decode(data.bytes);
+        const value = JSON.parse(text);
+        const input = sourceMapCodecInputSchema.parse(value);
+        if (Buffer.byteLength(input.text) > WEB_SOURCE_MAP_LIMITS.mapBytes)
+            throw new SourceMapFormatFailure("limit", "Source map exceeds the 4 MiB codec input budget.");
+        const report = traceSourceMap(input.text, input.url, input.position);
+        const reply = JSON.stringify(sourceMapCodecReplySchema.parse({ state: "success", report }));
+        if (Buffer.byteLength(reply) > WEB_SOURCE_MAP_LIMITS.outputBytes)
+            throw new SourceMapFormatFailure("limit", "Complete source-map point evidence exceeds the 32 MiB output budget; no partial evidence was returned.");
+        return reply;
+    }
+    catch (cause) {
+        if (!(cause instanceof SourceMapFormatFailure ||
+            cause instanceof z.ZodError ||
+            cause instanceof SyntaxError))
+            throw cause;
+        return JSON.stringify({
+            state: "failure",
+            reason: cause instanceof SourceMapFormatFailure ? cause.reason : "format",
+            message: cause.message,
+        });
+    }
+};
+process.stdout.write(await execute());

package/dist/javascript/sourceMaps/SourceMapCodecProtocol.js

@@ -0,0 +1,20 @@
+import { z } from "zod";
+import { webSourceMapReportSchema, webSourcePositionSchema, } from "../../domain/webSourceLocation.js";
+/** Trusted codec process input; captured application code is never evaluated. */
+export const sourceMapCodecInputSchema = z.strictObject({
+    text: z.string(),
+    url: z.string().min(1),
+    position: webSourcePositionSchema,
+});
+/** Codec success or a specific producer/resource constraint. */
+export const sourceMapCodecReplySchema = z.discriminatedUnion("state", [
+    z.strictObject({
+        state: z.literal("success"),
+        report: webSourceMapReportSchema,
+    }),
+    z.strictObject({
+        state: z.literal("failure"),
+        reason: z.enum(["format", "unsupported", "limit"]),
+        message: z.string(),
+    }),
+]);

package/dist/javascript/sourceMaps/SourceMapCommand.js

@@ -0,0 +1,176 @@
+import { randomUUID } from "node:crypto";
+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 { 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 { ProviderStartupDeadline } from "../../process/ProviderDeadline.js";
+import { cleanupOwnedProcessGroup } from "../../process/ProcessOwnership.js";
+import { ProviderProcessSupervisor, spawnOwnedProviderProcess, } from "../../process/ProviderProcess.js";
+const OPERATION = "trace_web_source_location";
+const PROVIDER = "source-map-decoder";
+/** Run a trusted codec command and release its process/root before returning output. */
+export const runSourceMapCommand = async (request, path, options, dependencies) => {
+    const deadline = new ProviderStartupDeadline(WEB_SOURCE_MAP_LIMITS.decodeTimeoutMs, options?.signal);
+    const command = new OwnedCodec(path, dependencies, deadline);
+    let result;
+    try {
+        await command.start(request);
+        result = ok(await command.collect());
+    }
+    catch (cause) {
+        result = err(command.failure(cause));
+    }
+    finally {
+        deadline.dispose();
+    }
+    const cleanup = await command.close(result.ok ? null : result.error.message);
+    if (cleanup !== undefined)
+        return err(cleanup);
+    return result.ok && options?.signal?.aborted
+        ? err(new AnalysisCancelledError(OPERATION))
+        : result;
+};
+class OwnedCodec {
+    path;
+    dependencies;
+    deadline;
+    #runId = `rea-source-map-${randomUUID()}`;
+    #runtime;
+    #supervisor;
+    #oversized = false;
+    #processError;
+    constructor(path, dependencies, deadline) {
+        this.path = path;
+        this.dependencies = dependencies;
+        this.deadline = deadline;
+    }
+    async start(request) {
+        this.check();
+        this.#runtime = await (this.dependencies.createRuntime ??
+            (() => PrivateRuntimeRoot.create({ prefix: "rea-source-map-" })))();
+        this.check();
+        const requestPath = join(this.#runtime.path, "request.json");
+        await writeFile(requestPath, request, {
+            flag: "wx",
+            mode: 0o600,
+            signal: this.deadline.signal,
+        });
+        this.check();
+        const environment = {
+            ...(this.dependencies.environment ?? process.env),
+            UV_THREADPOOL_SIZE: "1",
+        };
+        delete environment.NODE_OPTIONS;
+        const spawned = await (this.dependencies.launcher ?? spawnOwnedProviderProcess)({
+            command: process.execPath,
+            arguments: [
+                "--max-old-space-size=192",
+                "--max-semi-space-size=8",
+                "--v8-pool-size=1",
+                "--single-threaded",
+                "--stack_size=2048",
+                fileURLToPath(new URL("./SourceMapCodecProcess.js", import.meta.url)),
+                requestPath,
+            ],
+            runId: this.#runId,
+            cwd: this.#runtime.path,
+            hostEnvironment: environment,
+        });
+        this.#supervisor = new ProviderProcessSupervisor({
+            ...spawned,
+            ownsProcessLifetime: true,
+            cleanup: spawned.cleanup ??
+                (() => cleanupOwnedProcessGroup(spawned.ownership)),
+        }, {
+            onDiagnostic: (event) => {
+                if (event.type === "error")
+                    this.#processError = event.message;
+                if (event.type === "output" &&
+                    event.totalBytes >
+                        (event.stream === "stdout"
+                            ? WEB_SOURCE_MAP_LIMITS.outputBytes
+                            : 1024 * 1024))
+                    this.#oversized = true;
+            },
+        });
+    }
+    async collect() {
+        const supervisor = this.#supervisor;
+        if (supervisor === undefined)
+            throw new Error("Codec process was not acquired");
+        while (!(await supervisor.waitForOutputClose(50)))
+            this.check();
+        this.check();
+        const snapshot = supervisor.snapshot();
+        if (snapshot.exitCode !== 0 || snapshot.signal !== null)
+            throw new ProviderAdapterError(PROVIDER, OPERATION, {
+                diagnostics: {
+                    map_path: this.path,
+                    exit_code: snapshot.exitCode ?? null,
+                    signal: snapshot.signal ?? null,
+                    stderr: snapshot.stderr.text,
+                },
+            });
+        return snapshot.stdout.text;
+    }
+    check() {
+        if (this.deadline.interruption === "cancelled")
+            throw new AnalysisCancelledError(OPERATION);
+        if (this.deadline.interruption === "timeout")
+            throw new AnalysisTimeoutError(OPERATION, WEB_SOURCE_MAP_LIMITS.decodeTimeoutMs);
+        if (this.#oversized)
+            throw new AnalysisOutputError(OPERATION, "Codec output exceeds its complete-evidence or diagnostic budget.");
+        if (this.#processError !== undefined)
+            throw new ProviderAdapterError(PROVIDER, OPERATION, {
+                diagnostics: { map_path: this.path, error_message: this.#processError },
+            });
+    }
+    failure(cause) {
+        if (this.deadline.interruption === "cancelled")
+            return new AnalysisCancelledError(OPERATION);
+        if (this.deadline.interruption === "timeout")
+            return new AnalysisTimeoutError(OPERATION, WEB_SOURCE_MAP_LIMITS.decodeTimeoutMs);
+        if (cause instanceof AnalysisError)
+            return cause;
+        return cause instanceof PrivateRuntimeRootUnavailableError
+            ? new AnalysisCapabilityUnavailableError(PROVIDER, OPERATION, cause.message, { cause })
+            : new ProviderAdapterError(PROVIDER, OPERATION, {
+                cause,
+                diagnostics: { map_path: this.path, error_message: message(cause) },
+            });
+    }
+    async close(previousError) {
+        const failures = [];
+        if (this.#supervisor !== undefined) {
+            const stopped = await this.#supervisor.stop();
+            if (stopped.status === "incomplete")
+                failures.push(stopped.reason);
+        }
+        if (this.#runtime !== undefined) {
+            try {
+                await this.#runtime.close();
+            }
+            catch (cause) {
+                failures.push(message(cause));
+            }
+        }
+        return failures.length === 0
+            ? undefined
+            : new ProviderCleanupError(PROVIDER, [
+                this.#runId,
+                ...(this.#runtime === undefined ? [] : [this.#runtime.path]),
+            ], {
+                map_path: this.path,
+                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

@@ -0,0 +1,61 @@
+import { AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisInputError, AnalysisOutputError, } from "../../domain/analysisErrorCore.js";
+import { ArtifactOperationError } from "../../domain/artifactOperationError.js";
+import { err, ok } from "../../domain/result.js";
+import { WEB_SOURCE_MAP_LIMITS, } from "../../domain/webSourceLocation.js";
+import { sourceMapCodecInputSchema, sourceMapCodecReplySchema, } from "./SourceMapCodecProtocol.js";
+import { runSourceMapCommand, } from "./SourceMapCommand.js";
+const OPERATION = "trace_web_source_location";
+/** Integrate the pinned upstream codec through an independently bounded owned process. */
+export class SourceMapDecoder {
+    dependencies;
+    constructor(dependencies = {}) {
+        this.dependencies = dependencies;
+    }
+    /** Return complete point evidence after process and private-root cleanup. */
+    async trace(input, options) {
+        if (options?.signal?.aborted)
+            return err(new AnalysisCancelledError(OPERATION));
+        const request = sourceMapCodecInputSchema.safeParse({
+            text: input.text,
+            url: input.url,
+            position: input.position,
+        });
+        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 response = await runSourceMapCommand(serialized, input.path, options, this.dependencies);
+        if (!response.ok)
+            return response;
+        let value;
+        try {
+            value = JSON.parse(response.value);
+        }
+        catch (cause) {
+            return err(new AnalysisOutputError(OPERATION, `Malformed codec JSON reply: ${cause instanceof Error ? cause.message : String(cause)}`));
+        }
+        const reply = sourceMapCodecReplySchema.safeParse(value);
+        if (!reply.success)
+            return err(new AnalysisOutputError(OPERATION, `Malformed codec reply: ${reply.error.message}`));
+        if (options?.signal?.aborted)
+            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 codecFailure = (path, reason, detail) => err(reason === "limit"
+    ? new ArtifactOperationError(OPERATION, "limit", undefined, `${path}: ${detail}`)
+    : reason === "unsupported"
+        ? new AnalysisCapabilityUnavailableError("source-map-decoder", OPERATION, "unsupported_source_map_profile", { userMessage: `${path}: ${detail}` })
+        : new AnalysisInputError(OPERATION, undefined, [
+            {
+                path: ["source_map", "path"],
+                reason: "invalid_format",
+                message: `${path}: ${detail}`,
+            },
+        ]));

package/dist/javascript/sourceMaps/SourceMapFormat.js

@@ -0,0 +1,185 @@
+import { z } from "zod";
+import { WEB_SOURCE_MAP_LIMITS } from "../../domain/webSourceLocation.js";
+const leafSchema = z.object({
+    version: z.literal(3),
+    file: z.string().nullable().optional(),
+    sourceRoot: z.string().nullable().optional(),
+    sources: z.array(z.string().nullable()),
+    sourcesContent: z.array(z.string().nullable()).nullable().optional(),
+    names: z.array(z.string()).default([]),
+    mappings: z.string().regex(/^[A-Za-z0-9+/,;]*$/u),
+    ignoreList: z.array(z.number().int().min(0)).optional(),
+    x_google_ignoreList: z.array(z.number().int().min(0)).optional(),
+});
+const mapHeaderSchema = z.object({
+    version: z.literal(3),
+    file: z.string().nullable().optional(),
+    sections: z.unknown().optional(),
+});
+const sectionSchema = z.object({
+    offset: z.object({
+        line: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+        column: z.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+    }),
+    map: z.unknown().optional(),
+    url: z.string().optional(),
+});
+const indexedSchema = z.object({
+    version: z.literal(3),
+    sections: z.array(sectionSchema),
+});
+/** A decoder-profile failure with an actionable producer constraint. */
+export class SourceMapFormatFailure extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+    }
+}
+const compare = (a, b) => a.line - b.line || a.column - b.column;
+const addOffset = (base, offset) => {
+    const result = {
+        line: base.line + offset.line,
+        column: offset.column + (offset.line === 0 ? base.column : 0),
+    };
+    if (!Number.isSafeInteger(result.line) ||
+        !Number.isSafeInteger(result.column) ||
+        result.line >= WEB_SOURCE_MAP_LIMITS.decodedRows)
+        throw new SourceMapFormatFailure("limit", "Indexed offset exceeds the 262144 generated-row decoder budget.");
+    return result;
+};
+const addSections = (node, pending) => {
+    const sections = indexedSchema.parse(node.value).sections;
+    for (const [index, section] of sections.entries()) {
+        const previous = sections[index - 1];
+        if (previous !== undefined && compare(section.offset, previous.offset) <= 0)
+            throw new SourceMapFormatFailure("format", "Indexed section offsets must be strictly increasing.");
+        if (section.url !== undefined)
+            throw new SourceMapFormatFailure("unsupported", `External source-map section URL is not fetched: ${section.url}`);
+        if (section.map === undefined)
+            throw new SourceMapFormatFailure("format", "Indexed section requires an embedded map.");
+    }
+    for (let index = sections.length - 1; index >= 0; index -= 1) {
+        const section = sections[index];
+        if (section === undefined)
+            continue;
+        const next = sections[index + 1];
+        const nextOffset = next === undefined ? null : addOffset(node.offset, next.offset);
+        const stop = nextOffset === null
+            ? node.stop
+            : node.stop === null || compare(nextOffset, node.stop) < 0
+                ? nextOffset
+                : node.stop;
+        const offset = addOffset(node.offset, section.offset);
+        if (node.stop !== null && compare(offset, node.stop) >= 0)
+            throw new SourceMapFormatFailure("format", "Nested source-map section overlaps its enclosing boundary.");
+        pending.push({
+            value: section.map,
+            path: [...node.path, index],
+            offset,
+            stop,
+        });
+    }
+};
+const inspectMappingLayout = (mappings) => {
+    let lines = 1;
+    let segments = 0;
+    let components = 0;
+    let inSegment = false;
+    let continued = false;
+    let digits = 0;
+    const finish = () => {
+        if (continued)
+            throw new SourceMapFormatFailure("format", "Source-map VLQ ends with an unfinished continuation.");
+        if (inSegment && ![1, 4, 5].includes(components))
+            throw new SourceMapFormatFailure("format", "Source-map segment requires one, four or five VLQ components.");
+    };
+    for (const character of mappings) {
+        if (character === "," || character === ";") {
+            finish();
+            inSegment = false;
+            components = 0;
+            if (character === ";")
+                lines += 1;
+        }
+        else {
+            digits += 1;
+            if ((digits === 7 && !/[A-Dg-j]/u.test(character)) ||
+                (digits > 7 && character !== "A" && character !== "g"))
+                throw new SourceMapFormatFailure("format", "Source-map VLQ exceeds the format's 32-bit quantity representation.");
+            if (!inSegment)
+                segments += 1;
+            inSegment = true;
+            continued = /[g-z0-9+/]/u.test(character);
+            if (!continued) {
+                components += 1;
+                digits = 0;
+            }
+        }
+        if (segments > WEB_SOURCE_MAP_LIMITS.decodedSegments ||
+            lines > WEB_SOURCE_MAP_LIMITS.decodedRows)
+            throw new SourceMapFormatFailure("limit", "Source-map layout exceeds the 262144 segment/generated-row decoder budget.");
+    }
+    finish();
+    return { lines, segments };
+};
+/** 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 value = JSON.parse(jsonText);
+    const root = mapHeaderSchema.parse(value);
+    const declarations = [];
+    const leaves = [];
+    const pending = [
+        { value, path: [], offset: { line: 0, column: 0 }, stop: null },
+    ];
+    let segmentCount = 0;
+    while (pending.length > 0) {
+        const node = pending.pop();
+        if (node === undefined)
+            break;
+        if (node.path.length > WEB_SOURCE_MAP_LIMITS.sectionDepth)
+            throw new SourceMapFormatFailure("limit", "Indexed source-map nesting exceeds the 64-level decoder stack budget.");
+        if (mapHeaderSchema.parse(node.value).sections !== undefined) {
+            addSections(node, pending);
+            continue;
+        }
+        const leaf = leafSchema.parse(node.value);
+        const layout = inspectMappingLayout(leaf.mappings);
+        segmentCount += layout.segments;
+        if (segmentCount > WEB_SOURCE_MAP_LIMITS.decodedSegments ||
+            node.offset.line + layout.lines > WEB_SOURCE_MAP_LIMITS.decodedRows)
+            throw new SourceMapFormatFailure("limit", "Source-map layout exceeds the 262144 segment/generated-row decoder budget.");
+        leaves.push({ map: leaf, offset: node.offset, stop: node.stop });
+        for (const [sourceIndex, source] of leaf.sources.entries())
+            declarations.push({
+                sectionPath: node.path,
+                sourceIndex,
+                source,
+                root: leaf.sourceRoot ?? null,
+                content: leaf.sourcesContent?.[sourceIndex] ?? null,
+                ignored: (leaf.ignoreList ?? leaf.x_google_ignoreList ?? []).includes(sourceIndex),
+            });
+    }
+    // Absolute leaves adapt nested first-line column offsets before upstream AnyMap.
+    // Raw map bytes and the original section/source identities are retained separately.
+    const normalized = root.sections === undefined
+        ? leaves[0]?.map
+        : {
+            version: 3,
+            sections: leaves.map((leaf) => ({
+                offset: leaf.offset,
+                map: leaf.map,
+            })),
+        };
+    return {
+        jsonText: JSON.stringify(normalized),
+        format: root.sections === undefined ? "regular" : "indexed",
+        reportedFile: root.file ?? null,
+        declarations,
+        leaves,
+    };
+};