rea-agents 6.3.0 → 6.5.0

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");
+            }
+        }
+    }
+    const machine = reader.u16(18);
+    return {
+        format: "elf",
+        architecture: elfArchitecture(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;
+const elfArchitecture = (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}`;
+};

package/dist/go/GoMachoImage.js

@@ -0,0 +1,164 @@
+import { declaredFileRange, GoBinaryFormatFailure, GoBinaryReader, mappedFileOffset, } from "./GoBinaryContainer.js";
+/** Read thin Mach-O images, retaining the slice's exact file-backed mappings. */
+export const readGoMachoImage = (bytes) => {
+    const magic = bytes.readUInt32BE(0);
+    const little = magic === 0xcefaedfe || magic === 0xcffaedfe;
+    const bits = magic === 0xfeedfacf || magic === 0xcffaedfe ? 64 : 32;
+    const reader = new GoBinaryReader(bytes, little);
+    const headerSize = bits === 64 ? 32 : 28;
+    reader.range(0, headerSize, "Mach-O header");
+    const count = reader.u32(16);
+    const commandBytes = reader.u32(20);
+    const commandStart = reader.table(BigInt(headerSize), commandBytes, 1, "Mach-O load commands");
+    if (count > Math.floor(commandBytes / 8))
+        throw new GoBinaryFormatFailure("malformed", "Mach-O command count exceeds its load-command range");
+    const mappings = [];
+    const zeroFills = [];
+    const sections = [];
+    const named = [];
+    let fallback = null;
+    let offset = commandStart;
+    const end = commandStart + commandBytes;
+    for (let index = 0; index < count; index++) {
+        const command = reader.u32(offset);
+        const size = reader.u32(offset + 4);
+        if (size < 8 || size % 4 !== 0 || size > end - offset)
+            throw new GoBinaryFormatFailure("malformed", "Mach-O load command size is invalid or truncated");
+        if (command === 1 || command === 0x19) {
+            const wide = command === 0x19;
+            if (wide !== (bits === 64))
+                throw new GoBinaryFormatFailure("malformed", "Mach-O segment command does not match the header width");
+            const segmentHeader = wide ? 72 : 56;
+            const sectionWidth = wide ? 80 : 68;
+            if (size < segmentHeader)
+                throw new GoBinaryFormatFailure("malformed", "Mach-O segment header is truncated");
+            const address = reader.word(offset + 24, bits);
+            const memorySize = reader.word(offset + (wide ? 32 : 28), bits);
+            const fileOffset = reader.word(offset + (wide ? 40 : 32), bits);
+            const fileSize = reader.word(offset + (wide ? 48 : 36), bits);
+            const maxProtection = reader.u32(offset + (wide ? 56 : 40));
+            const protection = reader.u32(offset + (wide ? 60 : 44));
+            const sectionCount = reader.u32(offset + (wide ? 64 : 48));
+            const unmapped = memorySize === 0n && protection === 0;
+            if ((!unmapped && fileSize > memorySize) ||
+                address + memorySize > 1n << BigInt(bits))
+                throw new GoBinaryFormatFailure("malformed", "Mach-O segment addresses or sizes are invalid");
+            if (sectionCount > Math.floor((size - segmentHeader) / sectionWidth))
+                throw new GoBinaryFormatFailure("malformed", "Mach-O section table exceeds its segment command");
+            const fileRange = fileSize === 0n
+                ? undefined
+                : reader.fileRange(fileOffset, fileSize, "Mach-O segment");
+            const mapping = unmapped || fileRange === undefined
+                ? undefined
+                : { ...fileRange, address };
+            const name = fixedName(reader.range(offset + 8, 16, "Mach-O segment name"));
+            if (mapping !== undefined && name !== "__PAGEZERO")
+                mappings.push(mapping);
+            if (memorySize > fileSize && name !== "__PAGEZERO")
+                zeroFills.push({
+                    address: address + fileSize,
+                    size: memorySize - fileSize,
+                });
+            if (fallback === null &&
+                mapping !== undefined &&
+                address !== 0n &&
+                protection === 3 &&
+                maxProtection === 3)
+                fallback = mapping;
+            for (let sectionIndex = 0; sectionIndex < sectionCount; sectionIndex++) {
+                const section = offset + segmentHeader + sectionIndex * sectionWidth;
+                const sectionName = fixedName(reader.range(section, 16, "Mach-O section name"));
+                sections.push(machoImageSection({
+                    reader,
+                    bits,
+                    wide,
+                    header: section,
+                    name: `${fixedName(reader.range(section + 16, 16, "Mach-O section segment"))},${sectionName}`,
+                    protection,
+                    unmapped: unmapped || mapping === undefined,
+                    segmentAddress: address,
+                    segmentMemorySize: memorySize,
+                    segmentFileOffset: fileOffset,
+                    segmentFileSize: fileSize,
+                }));
+                if (sectionName !== "__go_buildinfo")
+                    continue;
+                if (unmapped)
+                    throw new GoBinaryFormatFailure("malformed", "Mach-O build-info section is in an unmapped segment");
+                if (mapping === undefined)
+                    throw new GoBinaryFormatFailure("malformed", "Mach-O build-info section is not file mapped");
+                const sectionFlags = reader.u32(section + (wide ? 64 : 56));
+                if ([1, 0xc, 0x12].includes(sectionFlags & 0xff))
+                    throw new GoBinaryFormatFailure("malformed", "Mach-O build-info section is zero-fill data");
+                const sectionAddress = reader.word(section + 32, bits);
+                const sectionSize = reader.word(section + (wide ? 40 : 36), bits);
+                const sectionOffset = BigInt(reader.u32(section + (wide ? 48 : 40)));
+                const info = {
+                    ...reader.fileRange(sectionOffset, sectionSize, "Mach-O build-info section"),
+                    address: sectionAddress,
+                };
+                if (mappedFileOffset([mapping], sectionAddress, info.size) !== info.offset)
+                    throw new GoBinaryFormatFailure("malformed", "Mach-O build-info section disagrees with its segment");
+                named.push(info);
+            }
+        }
+        offset += size;
+    }
+    if (offset !== end)
+        throw new GoBinaryFormatFailure("malformed", "Mach-O load-command byte count does not match its commands");
+    if (named.length > 1)
+        throw new GoBinaryFormatFailure("malformed", "Mach-O has ambiguous build-info sections");
+    const cpu = reader.u32(4);
+    const names = new Map([
+        [7, "386"],
+        [0x01000007, "amd64"],
+        [12, "arm"],
+        [0x0100000c, "arm64"],
+        [18, "ppc"],
+        [0x01000012, "ppc64"],
+    ]);
+    return {
+        format: "macho",
+        architecture: names.get(cpu) ?? `macho-cpu-${cpu}`,
+        bits,
+        byte_order: little ? "little" : "big",
+        mappings,
+        zero_fills: zeroFills,
+        sections,
+        search: named.length > 0 ? named : fallback === null ? [] : [fallback],
+    };
+};
+const machoImageSection = ({ reader, bits, wide, header, name, protection, unmapped, segmentAddress, segmentMemorySize, segmentFileOffset, segmentFileSize, }) => {
+    const flags = reader.u32(header + (wide ? 64 : 56));
+    const zeroFill = [1, 0xc, 0x12].includes(flags & 0xff);
+    const sectionAddress = reader.word(header + 32, bits);
+    const sectionSize = reader.word(header + (wide ? 40 : 36), bits);
+    const sectionOffset = BigInt(reader.u32(header + (wide ? 48 : 40)));
+    const addressDelta = sectionAddress - segmentAddress;
+    const fileDelta = sectionOffset - segmentFileOffset;
+    const inSegmentMemory = addressDelta >= 0n &&
+        addressDelta <= segmentMemorySize &&
+        sectionSize <= segmentMemorySize - addressDelta;
+    const inSegmentFile = fileDelta >= 0n &&
+        fileDelta <= segmentFileSize &&
+        sectionSize <= segmentFileSize - fileDelta;
+    const range = unmapped
+        ? { offset: 0, size: 0, file_backed: false }
+        : declaredFileRange(reader.bytes.length, BigInt(reader.u32(header + (wide ? 48 : 40))), reader.word(header + (wide ? 40 : 36), bits));
+    const fileBacked = range.file_backed && !zeroFill && inSegmentMemory && inSegmentFile;
+    const readOnly = fileBacked &&
+        (protection & 1) !== 0 &&
+        (protection & 2) === 0 &&
+        (flags & 0x80000400) === 0;
+    return {
+        name,
+        ...range,
+        file_backed: fileBacked,
+        read_only: readOnly,
+        compressed: false,
+    };
+};
+const fixedName = (bytes) => {
+    const nul = bytes.indexOf(0);
+    return bytes.subarray(0, nul < 0 ? bytes.length : nul).toString("latin1");
+};

package/dist/go/GoModuleText.js

@@ -0,0 +1,217 @@
+const utf8 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+const escapes = new Map([
+    ["a", 7],
+    ["b", 8],
+    ["f", 12],
+    ["n", 10],
+    ["r", 13],
+    ["t", 9],
+    ["v", 11],
+    ["\\", 92],
+    ['"', 34],
+]);
+const quoted = (input) => {
+    if (input.startsWith("`")) {
+        const end = input.indexOf("`", 1);
+        return end < 0
+            ? null
+            : { value: input.slice(1, end).replace(/\r/g, ""), end: end + 1 };
+    }
+    if (!input.startsWith('"'))
+        return null;
+    const output = Buffer.alloc(input.length * 3);
+    let length = 0;
+    for (let index = 1; index < input.length;) {
+        const character = input[index];
+        if (character === '"') {
+            try {
+                return {
+                    value: utf8.decode(output.subarray(0, length)),
+                    end: index + 1,
+                };
+            }
+            catch {
+                return null;
+            }
+        }
+        if (character === "\n")
+            return null;
+        if (character !== "\\") {
+            const point = input.codePointAt(index);
+            if (point === undefined)
+                return null;
+            length += output.write(String.fromCodePoint(point), length, "utf8");
+            index += point > 0xffff ? 2 : 1;
+            continue;
+        }
+        const escaped = input[index + 1];
+        if (escaped === undefined)
+            return null;
+        const simple = escapes.get(escaped);
+        if (simple !== undefined) {
+            output[length++] = simple;
+            index += 2;
+            continue;
+        }
+        const digits = escaped === "x" ? 2 : escaped === "u" ? 4 : escaped === "U" ? 8 : 0;
+        if (digits > 0) {
+            const encoded = input.slice(index + 2, index + 2 + digits);
+            if (encoded.length !== digits || !/^[a-f\d]+$/i.test(encoded))
+                return null;
+            const point = Number.parseInt(encoded, 16);
+            if (escaped === "x")
+                output[length++] = point;
+            else {
+                if (point > 0x10ffff || (point >= 0xd800 && point <= 0xdfff))
+                    return null;
+                length += output.write(String.fromCodePoint(point), length, "utf8");
+            }
+            index += 2 + digits;
+            continue;
+        }
+        const octal = input.slice(index + 1, index + 4);
+        if (!/^[0-7]{3}$/.test(octal))
+            return null;
+        const byte = Number.parseInt(octal, 8);
+        if (byte > 255)
+            return null;
+        output[length++] = byte;
+        index += 4;
+    }
+    return null;
+};
+const setting = (input) => {
+    let key;
+    let rawValue;
+    if (input.startsWith('"') || input.startsWith("`")) {
+        const decoded = quoted(input);
+        if (decoded === null || input[decoded.end] !== "=")
+            return null;
+        key = decoded.value;
+        rawValue = input.slice(decoded.end + 1);
+    }
+    else {
+        const separator = input.indexOf("=");
+        if (separator < 1)
+            return null;
+        key = input.slice(0, separator);
+        if (/[= \t\r\n"`]/.test(key))
+            return null;
+        rawValue = input.slice(separator + 1);
+    }
+    if (rawValue.startsWith('"') || rawValue.startsWith("`")) {
+        const decoded = quoted(rawValue);
+        return decoded !== null && decoded.end === rawValue.length
+            ? { key, value: decoded.value }
+            : null;
+    }
+    return /[ \t\r\n"`]/.test(rawValue) ? null : { key, value: rawValue };
+};
+const moduleLine = (fields) => {
+    const [path, version] = fields;
+    if ((fields.length !== 2 && fields.length !== 3) ||
+        path === undefined ||
+        version === undefined)
+        return null;
+    return { path, version, sum: fields[2] ?? null, replacement: null };
+};
+function* moduleSourceLines(source) {
+    let start = 0;
+    while (start < source.length) {
+        const newline = typeof source === "string"
+            ? source.indexOf("\n", start)
+            : source.indexOf(10, start);
+        const end = newline < 0 ? source.length : newline;
+        let line;
+        if (typeof source === "string")
+            line = source.slice(start, end);
+        else {
+            const bytes = source.subarray(start, end);
+            try {
+                line = utf8.decode(bytes);
+            }
+            catch {
+                line = bytes;
+            }
+        }
+        yield { line, terminated: newline >= 0 };
+        if (newline < 0)
+            return;
+        start = newline + 1;
+    }
+}
+const modulePrefixes = ["mod\t", "dep\t", "=>\t"].map((prefix) => Buffer.from(prefix));
+const parseModuleRecords = (source) => {
+    let path = null;
+    let main = null;
+    const dependencies = [];
+    const settings = [];
+    const unparsed_lines = [];
+    const unparsed_line_bytes_base64 = [];
+    let last = null;
+    for (const { line, terminated } of moduleSourceLines(source)) {
+        if (typeof line !== "string") {
+            unparsed_line_bytes_base64.push(line.toString("base64"));
+            if (modulePrefixes.some((prefix) => line.subarray(0, prefix.length).equals(prefix)))
+                last = null;
+            continue;
+        }
+        if (line === "")
+            continue;
+        if (!terminated) {
+            unparsed_lines.push(line);
+            continue;
+        }
+        if (line.startsWith("path\t") && path === null) {
+            path = line.slice(5);
+            continue;
+        }
+        if (line.startsWith("mod\t") || line.startsWith("dep\t")) {
+            const value = moduleLine(line.slice(4).split("\t"));
+            last = null;
+            if (value !== null && (!line.startsWith("mod\t") || main === null)) {
+                if (line.startsWith("mod\t"))
+                    main = value;
+                else
+                    dependencies.push(value);
+                last = value;
+                continue;
+            }
+        }
+        else if (line.startsWith("=>\t")) {
+            const fields = line.slice(3).split("\t");
+            const value = moduleLine(fields);
+            if (fields.length === 3 && value !== null && last !== null) {
+                last.replacement = {
+                    path: value.path,
+                    version: value.version,
+                    sum: value.sum,
+                };
+                last = null;
+                continue;
+            }
+            last = null;
+        }
+        else if (line.startsWith("build\t")) {
+            const value = setting(line.slice(6));
+            if (value !== null) {
+                settings.push(value);
+                continue;
+            }
+        }
+        unparsed_lines.push(line);
+    }
+    return {
+        path,
+        main,
+        dependencies,
+        settings,
+        unparsed_lines,
+        unparsed_line_bytes_base64,
+        complete: unparsed_lines.length + unparsed_line_bytes_base64.length === 0,
+    };
+};
+/** Decode Go's module records while preserving unsupported/malformed source lines. */
+export const parseGoModuleText = (text) => parseModuleRecords(text);
+/** Decode an unframed Go module body while retaining non-UTF-8 line bytes exactly. */
+export const parseGoModuleBytes = (bytes) => parseModuleRecords(bytes);