rea-agents 6.4.0 → 6.7.0

package/dist/go/GoBinaryImage.js

@@ -0,0 +1,210 @@
+import { GoBinaryFormatFailure, GoBinaryResourceFailure, GoBinaryReader, goUtf8, mappedFileOffset, isZeroFilledSpan, } from "./GoBinaryContainer.js";
+import { classifyFatContainerIdentity, readFatContainerHeader, } from "../domain/apple/machoContainer.js";
+import { readGoElfImage } from "./GoElfImage.js";
+import { readGoMachoImage } from "./GoMachoImage.js";
+import { readGoPeImage } from "./GoPeImage.js";
+export { GoBinaryFormatFailure, GoBinaryResourceFailure, } from "./GoBinaryContainer.js";
+const MAGIC = Buffer.from("ff20476f206275696c64696e663a", "hex");
+const MODULE_START = Buffer.from("3077af0c9274080241e1c107e6d618e6", "hex");
+const MODULE_END = Buffer.from("f932433186182072008242104116d8f2", "hex");
+const MAX_BUILD_INFO_BYTES = 1024 * 1024;
+const MAX_HEADER_SEARCH_BYTES = 256 * 1024 * 1024;
+/** Inspect bounded executable bytes using native mappings, without loading or executing code. */
+export const readGoBinaryImage = (bytes) => {
+    const container = readGoBinaryContainer(bytes);
+    const { format, architecture, bits, byte_order } = container;
+    let selected = null;
+    const searched = new Set();
+    let remainingSearchBytes = MAX_HEADER_SEARCH_BYTES;
+    for (const search of container.search) {
+        // Identical file spans and alignment inspect the same candidate bytes.
+        // Partially overlapping spans still consume a cumulative work budget.
+        const identity = `${search.offset}:${search.size}:${search.address % 16n}`;
+        if (searched.has(identity))
+            continue;
+        searched.add(identity);
+        if (search.size > remainingSearchBytes)
+            throw new GoBinaryResourceFailure("search", MAX_HEADER_SEARCH_BYTES, "Go build-info discovery exceeds the cumulative 256 MiB header-search budget");
+        remainingSearchBytes -= search.size;
+        const header = findHeader(bytes, search);
+        if (header !== null) {
+            selected = { search, header };
+            break;
+        }
+    }
+    if (selected === null)
+        return { format, architecture, bits, byte_order, build_info: null };
+    const { search, header } = selected;
+    const verifyMapping = (size) => {
+        const address = search.address + BigInt(header - search.offset);
+        if (mappedFileOffset(container.mappings, address, size, container.zero_fills) !== header)
+            throw new GoBinaryFormatFailure("malformed", "Go build-info bytes disagree with their virtual mapping");
+    };
+    verifyMapping(32);
+    const reader = new GoBinaryReader(bytes, byte_order === "little");
+    const ptrSize = bytes[header + 14];
+    const flags = bytes[header + 15] ?? 0;
+    if ((flags & ~3) !== 0)
+        throw new GoBinaryFormatFailure("unsupported", "Go build-info flags contain an unsupported format bit");
+    if ((flags & 2) === 0 && (flags & 1) !== (byte_order === "big" ? 1 : 0))
+        throw new GoBinaryFormatFailure("malformed", "Go build-info byte order disagrees with the image");
+    const encoding = (flags & 2) !== 0 ? "inline" : "pointer";
+    const readInline = (offset, remaining) => readInlineString(reader, offset, remaining);
+    const sourceEnd = search.offset + search.size;
+    let version;
+    let module;
+    if (encoding === "inline") {
+        version = readInline(header + 32, sourceEnd - header - 32);
+        const next = version.location.offset + version.location.bytes;
+        module = readInline(next, sourceEnd - next);
+        verifyMapping(module.location.offset + module.location.bytes - header);
+    }
+    else {
+        if (ptrSize !== 4 && ptrSize !== 8)
+            throw new GoBinaryFormatFailure("malformed", "Go build-info pointer width must be 4 or 8");
+        if (ptrSize * 8 !== bits)
+            throw new GoBinaryFormatFailure("malformed", "Go build-info pointer width disagrees with the image");
+        const pointerBits = ptrSize === 8 ? 64 : 32;
+        version = readPointerString(reader, container, reader.word(header + 16, pointerBits));
+        const moduleField = header + 16 + ptrSize;
+        module = readOptionalModuleString(reader, container, reader.word(moduleField, pointerBits), moduleField);
+    }
+    if (version.location.bytes + module.location.bytes > MAX_BUILD_INFO_BYTES)
+        throw new GoBinaryResourceFailure("build-info", MAX_BUILD_INFO_BYTES, "Go build-info strings exceed the aggregate 1 MiB limit");
+    if (version.bytes.length === 0)
+        throw new GoBinaryFormatFailure("malformed", "Go build-info compiler version is empty");
+    const goVersion = observedText(version.bytes);
+    let moduleText = "";
+    if (module.bytes.length !== 0) {
+        if (module.bytes.length < 33 ||
+            !module.bytes.subarray(0, 16).equals(MODULE_START) ||
+            !module.bytes.subarray(-16).equals(MODULE_END) ||
+            module.bytes[module.bytes.length - 17] !== 10)
+            throw new GoBinaryFormatFailure("malformed", "Go module string framing is invalid");
+        moduleText = observedText(module.bytes.subarray(16, -16));
+    }
+    return {
+        format,
+        architecture,
+        bits,
+        byte_order,
+        build_info: {
+            header_offset: header,
+            encoding,
+            go_version: goVersion,
+            go_version_bytes_base64: version.bytes.toString("base64"),
+            module_text: moduleText,
+            module_bytes_base64: module.bytes.toString("base64"),
+            version_location: version.location,
+            module_location: module.location,
+        },
+    };
+};
+const observedText = (bytes) => {
+    try {
+        return goUtf8(bytes, "Go build string");
+    }
+    catch (cause) {
+        if (cause instanceof GoBinaryFormatFailure)
+            return null;
+        throw cause;
+    }
+};
+/** Identify an ELF, PE, or thin Mach-O image and its named file sections. */
+export const readGoBinaryContainer = (bytes) => {
+    if (bytes.subarray(0, 4).equals(Buffer.from([0x7f, 0x45, 0x4c, 0x46])))
+        return readGoElfImage(bytes);
+    if (bytes.subarray(0, 2).equals(Buffer.from("MZ")))
+        return readGoPeImage(bytes);
+    if (bytes.length >= 4) {
+        const magic = bytes.readUInt32BE();
+        if ([0xcafebabe, 0xcafebabf, 0xbebafeca, 0xbfbafeca].includes(magic)) {
+            const fatHeader = readFatContainerHeader(bytes, bytes.length);
+            if (fatHeader.state === "malformed")
+                throw new GoBinaryFormatFailure("malformed", fatHeader.reason);
+            const identity = fatHeader.state === "parsed"
+                ? classifyFatContainerIdentity(fatHeader, (offset) => {
+                    if (offset >= bytes.length)
+                        return undefined;
+                    if (offset + 4 > bytes.length)
+                        return null;
+                    return bytes.readUInt32BE(offset);
+                })
+                : undefined;
+            // An invalid FAT-shaped table is not proof of a Mach-O container: JVM
+            // constant-pool bytes can share both the magic and a known CPU value.
+            const confirmedFatMachO = identity?.state === "mach-o";
+            if (confirmedFatMachO)
+                throw new GoBinaryFormatFailure("unsupported", "Universal/fat Mach-O containers require selecting a thin slice");
+        }
+        if ([0xfeedface, 0xfeedfacf, 0xcefaedfe, 0xcffaedfe].includes(magic))
+            return readGoMachoImage(bytes);
+    }
+    throw new GoBinaryFormatFailure("unsupported", "Only ELF, PE, and thin Mach-O native images are supported");
+};
+const findHeader = (bytes, search) => {
+    if (search.size === 0)
+        return null;
+    const end = search.offset + search.size;
+    const selected = bytes.subarray(search.offset, end);
+    let offset = Number((16n - (search.address % 16n)) % 16n);
+    while (offset < selected.length) {
+        const match = selected.indexOf(MAGIC, offset);
+        if (match < 0)
+            return null;
+        const candidate = search.offset + match;
+        const address = search.address + BigInt(candidate - search.offset);
+        if (address % 16n === 0n) {
+            if (end - candidate < 32)
+                throw new GoBinaryFormatFailure("malformed", "Go build-info header is truncated");
+            return candidate;
+        }
+        offset = match + 1;
+    }
+    return null;
+};
+const readInlineString = (reader, offset, remaining) => {
+    let length = 0n;
+    for (let index = 0; index < 10; index++) {
+        if (index >= remaining)
+            throw new GoBinaryFormatFailure("malformed", "Go build-info varint is truncated");
+        const byte = reader.bytes[offset + index] ?? 0;
+        if (index === 9 && byte > 1)
+            throw new GoBinaryFormatFailure("malformed", "Go build-info varint overflows 64 bits");
+        length |= BigInt(byte & 127) << BigInt(index * 7);
+        if ((byte & 128) === 0) {
+            if (length > BigInt(MAX_BUILD_INFO_BYTES))
+                throw new GoBinaryResourceFailure("build-info", MAX_BUILD_INFO_BYTES, "Go build-info string length exceeds the 1 MiB limit");
+            const size = Number(length);
+            if (size > remaining - index - 1)
+                throw new GoBinaryFormatFailure("malformed", "Go build-info string range is truncated");
+            const start = offset + index + 1;
+            return {
+                bytes: reader.range(start, size, "Go build-info string"),
+                location: { offset: start, bytes: size },
+            };
+        }
+    }
+    throw new GoBinaryFormatFailure("malformed", "Go build-info varint is unterminated");
+};
+const readPointerString = (reader, container, address) => {
+    const { mappings, zero_fills: zeroFills, bits } = container;
+    const width = bits / 8;
+    const header = mappedFileOffset(mappings, address, width * 2, zeroFills);
+    const valueAddress = reader.word(header, bits);
+    const length = reader.word(header + width, bits);
+    if (length > BigInt(MAX_BUILD_INFO_BYTES))
+        throw new GoBinaryResourceFailure("build-info", MAX_BUILD_INFO_BYTES, "Go build-info pointer string length exceeds the 1 MiB limit");
+    const size = Number(length);
+    // Zero-length Go strings may carry a zero data pointer.
+    const offset = size === 0 && valueAddress === 0n
+        ? header
+        : mappedFileOffset(mappings, valueAddress, size, zeroFills);
+    return {
+        bytes: reader.range(offset, size, "Go build-info pointer string"),
+        location: { offset, bytes: size },
+    };
+};
+const readOptionalModuleString = (reader, container, address, pointerField) => isZeroFilledSpan(container.mappings, container.zero_fills, address, (container.bits / 8) * 2)
+    ? { bytes: Buffer.alloc(0), location: { offset: pointerField, bytes: 0 } }
+    : readPointerString(reader, container, address);

package/dist/go/GoBinaryProvider.js

@@ -0,0 +1,180 @@
+import { readStableArtifact } from "../artifacts/readStableArtifact.js";
+import { ArtifactFileCleanupFailure, assertArtifactReadActive, bindArtifactFileCleanup, artifactFileCancellationCause, } from "../artifacts/ArtifactFileOperation.js";
+import { ArtifactResourceScope } from "../artifacts/ArtifactResourceScope.js";
+import { ArtifactReaderFailure } from "../artifacts/ArtifactReader.js";
+import { analysisErrorWithCleanupFailure } from "../domain/analysisErrorCleanup.js";
+import { AnalysisError } from "../domain/analysisErrorBase.js";
+import { AnalysisAccessDeniedError, AnalysisArtifactChangedError, AnalysisCancelledError, AnalysisInputError, AnalysisOutputError, AnalysisResourceConstraintError, AnalysisUnsupportedTargetError, } from "../domain/analysisErrorCore.js";
+import { goBinarySchema, } from "../domain/go/goBinary.js";
+import { ProviderAdapterError } from "../domain/providerAdapterError.js";
+import { ProviderCleanupError } from "../domain/providerCleanupError.js";
+import { err, ok } from "../domain/result.js";
+import { readGoBinaryImage, GoBinaryFormatFailure, GoBinaryResourceFailure, } from "./GoBinaryImage.js";
+import { parseGoModuleBytes, parseGoModuleText } from "./GoModuleText.js";
+/** Bundled format reader identity; embedded compiler versions are separate observed facts. */
+export const GO_BINARY_PROVIDER_IDENTITY = {
+    id: "go-build-info",
+    name: "REA Go build-information reader",
+    version: "1",
+};
+const OPERATION = "inspect_go_binary";
+const INPUT_BYTES = 256 * 1024 * 1024;
+const OUTPUT_BYTES = 8 * 1024 * 1024;
+const failureForPrimary = (cause, path) => {
+    if (cause instanceof AnalysisError)
+        return cause;
+    if (cause instanceof ArtifactReaderFailure && cause.reason === "integrity")
+        return new AnalysisArtifactChangedError(OPERATION, path, cause.message, {
+            cause,
+        });
+    if (cause instanceof ArtifactReaderFailure && cause.reason === "cancelled")
+        return new AnalysisCancelledError(OPERATION, {
+            cause: artifactFileCancellationCause(cause),
+        });
+    if (cause instanceof GoBinaryResourceFailure)
+        return new AnalysisResourceConstraintError(OPERATION, cause.boundary === "search" ? "cpu" : "memory", `Selected artifact ${path}: ${cause.message}`, { boundary: cause.boundary, maximum_bytes: cause.maximum_bytes }, { cause });
+    if (cause instanceof GoBinaryFormatFailure)
+        return cause.kind === "unsupported"
+            ? new AnalysisUnsupportedTargetError(OPERATION, path, cause.message, {
+                cause,
+            })
+            : new AnalysisInputError(OPERATION, { cause }, [
+                {
+                    path: ["path"],
+                    reason: "invalid_format",
+                    message: `Selected artifact ${path}: ${cause.message}`,
+                },
+            ]);
+    if (cause instanceof ArtifactReaderFailure) {
+        if (cause.reason === "limit")
+            return new AnalysisResourceConstraintError(OPERATION, "file-size", cause.message, { maximum_input_bytes: INPUT_BYTES }, {
+                cause,
+                remediationAction: "Select a suitable stable artifact within the reported input byte allowance. Do not truncate required bytes; retrying the unchanged oversized input will fail again.",
+            });
+        if (cause.reason === "path")
+            return new AnalysisInputError(OPERATION, { cause }, [
+                { path: ["path"], reason: "invalid_format", message: cause.message },
+            ]);
+    }
+    if (cause instanceof Error && "code" in cause) {
+        if (cause.code === "EACCES" || cause.code === "EPERM")
+            return new AnalysisAccessDeniedError(OPERATION, path, cause.code, {
+                cause,
+            });
+        if (["ENOENT", "ENOTDIR", "ELOOP", "ENAMETOOLONG"].includes(String(cause.code)))
+            return new AnalysisInputError(OPERATION, { cause }, [
+                {
+                    path: ["path"],
+                    reason: "invalid_value",
+                    message: `Selected artifact could not be read (${String(cause.code)}): ${path}.`,
+                },
+            ]);
+    }
+    return new ProviderAdapterError(GO_BINARY_PROVIDER_IDENTITY.id, OPERATION, {
+        cause,
+        diagnostics: {
+            path,
+            reason: cause instanceof Error ? cause.message : String(cause),
+        },
+    });
+};
+const failureFor = (cause, path, signal) => {
+    const primary = cause instanceof ArtifactFileCleanupFailure &&
+        cause.fileCleanupFailure.outcome.kind === "failed"
+        ? failureForPrimary(cause.fileCleanupFailure.outcome.cause, path)
+        : cause instanceof ArtifactFileCleanupFailure && signal?.aborted
+            ? new AnalysisCancelledError(OPERATION, { cause: signal.reason })
+            : failureForPrimary(cause, path);
+    if (!(cause instanceof ArtifactReaderFailure) || cause.cleanup === undefined)
+        return primary;
+    const cleanup = new ProviderCleanupError(GO_BINARY_PROVIDER_IDENTITY.id, cause.cleanup.resources, { reason: cause.cleanup.reason }, { operation: OPERATION, cause });
+    const error = analysisErrorWithCleanupFailure(primary, cleanup, OPERATION);
+    bindArtifactFileCleanup(cause, error);
+    return error;
+};
+const outputLimit = (path) => new AnalysisResourceConstraintError(OPERATION, "transport", `Complete Go metadata for ${path} exceeds the inline output budget; no partial success is returned.`, { maximum_output_bytes: OUTPUT_BYTES });
+/** Fixed reader boundaries plus unknowns left by the observed metadata. */
+const limitationsFor = (info, module) => [
+    "Embedded build metadata is observed file content, not proof of compiler identity, dependency authenticity or runtime behavior.",
+    "Only Go build information is inspected; function names, source mappings, type metadata and decompiled code are not recovered.",
+    "Resource guards bound stable artifact reads and cumulative header searches to 256 MiB each, aggregate embedded strings to 1 MiB, structural table decoding to 16 MiB and complete metadata payloads to 8 MiB; these are not operating-system memory or CPU limits.",
+    ...(info !== null && (info.go_version === null || info.module_text === null)
+        ? [
+            "Some embedded Go strings contain non-UTF8 bytes; undecodable text is null and exact source bytes are preserved as base64.",
+        ]
+        : []),
+    ...(info === null
+        ? [
+            "No recognized Go build-info record was found in the inspected image; absent metadata does not establish that the binary is not Go.",
+        ]
+        : []),
+    ...(module !== null && module.main === null
+        ? [
+            "Dependency coverage is unknown because no main-module record was decoded from the embedded module information, as in GOPATH-mode builds. Decoded dependency records remain visible; an empty list does not establish the absence of dependencies.",
+        ]
+        : []),
+    ...(module?.complete === false
+        ? [
+            "Some embedded module-text records could not be parsed completely; their original lines are preserved and additional metadata remains unknown.",
+        ]
+        : []),
+];
+/** Stable in-process metadata inspection without subprocesses, temporary files or Go installation. */
+export class GoBinaryProvider {
+    identity = GO_BINARY_PROVIDER_IDENTITY;
+    #resources = new ArtifactResourceScope();
+    async close() {
+        try {
+            await this.#resources.close();
+        }
+        catch (cause) {
+            if (!(cause instanceof ArtifactReaderFailure) ||
+                cause.cleanup === undefined)
+                throw cause;
+            const error = new ProviderCleanupError(GO_BINARY_PROVIDER_IDENTITY.id, cause.cleanup.resources, { reason: cause.cleanup.reason }, { cause, operation: OPERATION });
+            bindArtifactFileCleanup(cause, error);
+            throw error;
+        }
+    }
+    /** Read complete compiler/module metadata while preserving original byte identity and source ranges. */
+    async inspect(input, options) {
+        try {
+            return await this.#resources.run(async () => {
+                const snapshot = await readStableArtifact(input.path, INPUT_BYTES, options?.signal, undefined, this.#resources);
+                assertArtifactReadActive(options?.signal);
+                const image = readGoBinaryImage(snapshot.bytes);
+                const info = image.build_info;
+                if (info !== null &&
+                    ((info.module_text !== null &&
+                        Buffer.byteLength(info.module_text) > OUTPUT_BYTES) ||
+                        Buffer.byteLength(info.module_bytes_base64) > OUTPUT_BYTES))
+                    throw outputLimit(input.path);
+                const module = info === null
+                    ? null
+                    : info.module_text === null
+                        ? parseGoModuleBytes(Buffer.from(info.module_bytes_base64, "base64").subarray(16, -16))
+                        : parseGoModuleText(info.module_text);
+                const report = {
+                    ...image,
+                    artifact: {
+                        path: input.path,
+                        sha256: snapshot.sha256,
+                        bytes: snapshot.bytes.length,
+                    },
+                    build_info: info === null ? null : { ...info, module },
+                    limitations: limitationsFor(info, module),
+                };
+                if (Buffer.byteLength(JSON.stringify(report), "utf8") > OUTPUT_BYTES)
+                    throw outputLimit(input.path);
+                const parsed = goBinarySchema.safeParse(report);
+                if (!parsed.success)
+                    throw new AnalysisOutputError(OPERATION, "Go reader produced invalid source ranges or report values.", { cause: parsed.error });
+                assertArtifactReadActive(options?.signal);
+                return ok(parsed.data);
+            });
+        }
+        catch (cause) {
+            return err(failureFor(cause, input.path, options?.signal));
+        }
+    }
+}

package/dist/go/GoElfImage.js

@@ -0,0 +1,211 @@
+import { declaredFileRange, GoBinaryFormatFailure, GoBinaryReader, mappedFileOffset, } from "./GoBinaryContainer.js";
+import { readElfFixedHeader } from "../domain/elfFixedHeader.js";
+/** Read ELF build-info sections and file-backed program mappings. */
+export const readGoElfImage = (bytes) => {
+    const fixedHeader = readElfFixedHeader(bytes);
+    if (!fixedHeader.ok)
+        throw new GoBinaryFormatFailure("malformed", fixedHeader.error);
+    const { elfClass: bits, headerSize } = fixedHeader.value;
+    const reader = new GoBinaryReader(bytes, fixedHeader.value.byteOrder === "little");
+    const wide = bits === 64;
+    const phOffset = reader.word(wide ? 32 : 28, bits);
+    const shOffset = reader.word(wide ? 40 : 32, bits);
+    const phWidth = reader.u16(wide ? 54 : 42);
+    const shWidth = reader.u16(wide ? 58 : 46);
+    let phCount = reader.u16(wide ? 56 : 44);
+    let shCount = reader.u16(wide ? 60 : 48);
+    let namesIndex = reader.u16(wide ? 62 : 50);
+    if ((phCount !== 0 && phOffset < BigInt(headerSize)) ||
+        (shOffset !== 0n && shOffset < BigInt(headerSize)))
+        throw new GoBinaryFormatFailure("malformed", "ELF header table overlaps the native header");
+    if (shOffset !== 0n &&
+        (shCount === 0 || phCount === 0xffff || namesIndex === 0xffff)) {
+        if (shWidth < (wide ? 64 : 40))
+            throw new GoBinaryFormatFailure("malformed", "ELF extended section header width is invalid");
+        const first = reader.fileRange(shOffset, BigInt(shWidth), "ELF section zero").offset;
+        if (reader.u32(first + 4) !== 0)
+            throw new GoBinaryFormatFailure("malformed", "ELF initial section for extended numbering must have SHT_NULL type");
+        if (shCount === 0) {
+            const count = reader.word(first + (wide ? 32 : 20), bits);
+            if (count < 0xff00n || count > BigInt(Number.MAX_SAFE_INTEGER))
+                throw new GoBinaryFormatFailure("malformed", "ELF extended section count is invalid");
+            shCount = Number(count);
+        }
+        if (phCount === 0xffff) {
+            phCount = reader.u32(first + (wide ? 44 : 28));
+            if (phCount < 0xffff)
+                throw new GoBinaryFormatFailure("malformed", "ELF extended program count is below its reserved range");
+        }
+        if (namesIndex === 0xffff) {
+            namesIndex = reader.u32(first + (wide ? 40 : 24));
+            if (namesIndex < 0xff00)
+                throw new GoBinaryFormatFailure("malformed", "ELF extended section name index is below its reserved range");
+        }
+    }
+    else if (shOffset === 0n &&
+        (shCount !== 0 || namesIndex !== 0 || phCount === 0xffff)) {
+        throw new GoBinaryFormatFailure("malformed", "ELF section table is missing");
+    }
+    if (phCount !== 0 && phWidth < (wide ? 56 : 32))
+        throw new GoBinaryFormatFailure("malformed", "ELF program header width is invalid");
+    const phStart = reader.table(phOffset, phCount, phWidth, "ELF program headers");
+    const mappings = [];
+    const zeroFills = [];
+    const sections = [];
+    const fallback = [];
+    for (let index = 0; index < phCount; index++) {
+        const offset = phStart + index * phWidth;
+        if (reader.u32(offset) !== 1)
+            continue;
+        const flags = reader.u32(offset + (wide ? 4 : 24));
+        const fileOffset = reader.word(offset + (wide ? 8 : 4), bits);
+        const address = reader.word(offset + (wide ? 16 : 8), bits);
+        const size = reader.word(offset + (wide ? 32 : 16), bits);
+        const memorySize = reader.word(offset + (wide ? 40 : 20), bits);
+        if (size > memorySize || address + memorySize > 1n << BigInt(bits))
+            throw new GoBinaryFormatFailure("malformed", "ELF load segment sizes or addresses are invalid");
+        const mapping = {
+            ...(size === 0n
+                ? { offset: 0, size: 0 }
+                : reader.fileRange(fileOffset, size, "ELF load segment")),
+            address,
+        };
+        if (mapping.size !== 0)
+            mappings.push(mapping);
+        if (memorySize > size)
+            zeroFills.push({ address: address + size, size: memorySize - size });
+        if (mapping.size !== 0 && (flags & 3) === 2)
+            fallback.push(mapping);
+    }
+    let search = null;
+    if (shCount !== 0) {
+        if (shWidth < (wide ? 64 : 40) || namesIndex >= shCount)
+            throw new GoBinaryFormatFailure("malformed", "ELF section width or name-table index is invalid");
+        const shStart = reader.table(shOffset, shCount, shWidth, "ELF section headers");
+        if (namesIndex !== 0) {
+            const namesHeader = shStart + namesIndex * shWidth;
+            if (reader.u32(namesHeader + 4) !== 3)
+                throw new GoBinaryFormatFailure("malformed", "ELF section name table is not a string table");
+            const names = reader.fileRange(reader.word(namesHeader + (wide ? 24 : 16), bits), reader.word(namesHeader + (wide ? 32 : 20), bits), "ELF section names");
+            for (let index = 0; index < shCount; index++) {
+                const offset = shStart + index * shWidth;
+                const nameOffset = reader.u32(offset);
+                if (nameOffset >= names.size)
+                    throw new GoBinaryFormatFailure("malformed", "ELF section name offset is outside its string table");
+                recordElfSection(sections, {
+                    bytes,
+                    names,
+                    nameOffset,
+                    reader,
+                    bits,
+                    wide,
+                    header: offset,
+                });
+                // Comparing the complete fixed name avoids quadratic scans through malicious string tables.
+                const expectedName = Buffer.from(".go.buildinfo\0");
+                if (expectedName.length > names.size - nameOffset ||
+                    !bytes
+                        .subarray(names.offset + nameOffset, names.offset + nameOffset + expectedName.length)
+                        .equals(expectedName))
+                    continue;
+                if (search !== null)
+                    throw new GoBinaryFormatFailure("malformed", "ELF contains ambiguous build-info sections");
+                if (reader.u32(offset + 4) !== 1)
+                    throw new GoBinaryFormatFailure("malformed", "ELF build-info section is not file-backed data");
+                if ((reader.word(offset + 8, bits) & 0x800n) !== 0n)
+                    throw new GoBinaryFormatFailure("unsupported", "Compressed ELF build-info sections are unsupported");
+                const address = reader.word(offset + (wide ? 16 : 12), bits);
+                search = {
+                    ...reader.fileRange(reader.word(offset + (wide ? 24 : 16), bits), reader.word(offset + (wide ? 32 : 20), bits), "ELF build-info section"),
+                    address,
+                };
+                if (mappedFileOffset(mappings, address, search.size, zeroFills) !==
+                    search.offset)
+                    throw new GoBinaryFormatFailure("malformed", "ELF build-info section disagrees with its load mapping");
+            }
+        }
+    }
+    return {
+        format: "elf",
+        architecture: goArchitectureForElfMachine(fixedHeader.value.machine),
+        bits,
+        byte_order: reader.little ? "little" : "big",
+        mappings,
+        zero_fills: zeroFills,
+        sections,
+        search: search === null ? fallback : [search],
+    };
+};
+const recordElfSection = (sections, input) => {
+    const decoded = elfSectionName(input.bytes, input.names, input.nameOffset);
+    const header = {
+        reader: input.reader,
+        bits: input.bits,
+        wide: input.wide,
+        header: input.header,
+    };
+    switch (decoded.status) {
+        case "named":
+            sections.push(elfImageSection({ ...header, name: decoded.name }));
+            return;
+        case "truncated": {
+            // Names past this window stay out of .dep-v0 matching. Read-only
+            // bytes can still hold the only compiler path.
+            const section = elfImageSection({ ...header, name: "" });
+            if (section.read_only)
+                sections.push(section);
+            return;
+        }
+        case "unnamed":
+            return;
+        default: {
+            const unreachable = decoded;
+            return unreachable;
+        }
+    }
+};
+const elfSectionName = (bytes, names, nameOffset) => {
+    const start = names.offset + nameOffset;
+    const limit = Math.min(start + 64, names.offset + names.size);
+    const nul = bytes.subarray(start, limit).indexOf(0);
+    if (nul === 0)
+        return { status: "unnamed" };
+    if (nul < 0)
+        return { status: "truncated" };
+    return {
+        status: "named",
+        name: bytes.toString("latin1", start, start + nul),
+    };
+};
+const elfImageSection = ({ reader, bits, wide, header, name, }) => {
+    const type = reader.u32(header + 4);
+    const flags = reader.word(header + 8, bits);
+    const declared = declaredFileRange(reader.bytes.length, reader.word(header + (wide ? 24 : 16), bits), reader.word(header + (wide ? 32 : 20), bits));
+    // SHT_NOBITS offsets and sizes do not describe stored bytes.
+    const range = type === SHT_NOBITS ? { ...declared, file_backed: false } : declared;
+    const compressed = (flags & 0x800n) !== 0n;
+    const readOnly = type === 1 &&
+        range.file_backed &&
+        !compressed &&
+        (flags & 1n) === 0n &&
+        (flags & 4n) === 0n &&
+        (flags & 2n) !== 0n;
+    return { name, ...range, read_only: readOnly, compressed };
+};
+const SHT_NOBITS = 8;
+/** Go build-info vocabulary, including families outside REA target admission. */
+const goArchitectureForElfMachine = (machine) => {
+    const names = new Map([
+        [3, "386"],
+        [8, "mips"],
+        [20, "ppc"],
+        [21, "ppc64"],
+        [22, "s390"],
+        [40, "arm"],
+        [62, "amd64"],
+        [183, "arm64"],
+        [243, "riscv"],
+        [258, "loongarch"],
+    ]);
+    return names.get(machine) ?? `elf-machine-${machine}`;
+};