rea-agents 6.3.0 → 6.5.0

package/dist/wasm/WabtInterface.js

@@ -0,0 +1,309 @@
+import { AnalysisResourceConstraintError } from "../domain/analysisErrorCore.js";
+import { wasmInterfaceEntryRepresentationBytes } from "../domain/wasm/wasmInterface.js";
+import { WasmInterfaceBudget } from "./WasmInterfaceBudget.js";
+import { watString } from "./WabtString.js";
+/** Split direct WAT children only; function instruction bodies are never materialized. */
+const parts = (form) => {
+    const budget = new WasmInterfaceBudget();
+    const items = [];
+    let i = 1;
+    while (i < form.length - 1) {
+        if (/\s/u.test(form[i] ?? "")) {
+            i++;
+            continue;
+        }
+        if (form.startsWith("(;", i)) {
+            let depth = 1;
+            i += 2;
+            while (i < form.length && depth > 0) {
+                if (form.startsWith("(;", i)) {
+                    depth++;
+                    i += 2;
+                }
+                else if (form.startsWith(";)", i)) {
+                    depth--;
+                    i += 2;
+                }
+                else
+                    i++;
+            }
+            continue;
+        }
+        if (form.startsWith(";;", i)) {
+            const end = form.indexOf("\n", i);
+            i = end < 0 ? form.length : end + 1;
+            continue;
+        }
+        const start = i;
+        if (form[i] === '"') {
+            i = watString(form, i + 1).end;
+        }
+        else if (form[i] === "(") {
+            let depth = 1;
+            i++;
+            while (i < form.length && depth > 0) {
+                if (form[i] === '"')
+                    i = watString(form, i + 1).end;
+                else {
+                    if (form[i] === "(")
+                        depth++;
+                    else if (form[i] === ")")
+                        depth--;
+                    i++;
+                }
+            }
+        }
+        else {
+            while (i < form.length && !/[\s()]/u.test(form[i] ?? ""))
+                i++;
+            const atom = form.slice(start, i);
+            if (items[0] === "func" && items.length > 1 && !atom.startsWith("$"))
+                break;
+        }
+        if (i <= start)
+            throw new Error("Malformed WABT form");
+        budget.reserve(64 + (i - start) * 2);
+        items.push(form.slice(start, i));
+    }
+    return items;
+};
+const head = (form) => parts(form)[0];
+const admittedValues = new Set([
+    "i32",
+    "i64",
+    "f32",
+    "f64",
+    "v128",
+    "funcref",
+    "externref",
+]);
+const isValueType = (type) => admittedValues.has(type);
+const values = (form, category) => {
+    const result = [];
+    for (const item of parts(form)) {
+        if (!item.startsWith("("))
+            continue;
+        const group = parts(item);
+        if (group[0] !== category)
+            continue;
+        for (const type of group.slice(1).filter((t) => !t.startsWith("$"))) {
+            if (!isValueType(type))
+                return null;
+            result.push(type);
+        }
+    }
+    return result;
+};
+const functionType = (form, kind) => {
+    const params = values(form, "param");
+    const results = values(form, "result");
+    return params === null || results === null ? null : { kind, params, results };
+};
+const name = (text) => {
+    if (text?.startsWith('"') !== true)
+        throw new Error("WABT interface name is missing");
+    return new TextDecoder("utf8", { fatal: true, ignoreBOM: true }).decode(watString(text, 1).bytes);
+};
+const integer = (text) => {
+    if (!/^(?:\d+|0x[\da-f]+)$/iu.test(text))
+        return null;
+    return BigInt(text).toString();
+};
+/** Resolve index spaces at the producer, not from retained raw WAT in consumers. */
+const decodeWabtInterface = (forms, result) => {
+    const budget = new WasmInterfaceBudget();
+    const types = [];
+    const typeNames = new Map();
+    const definitions = new Map();
+    const typeSpaceUnknown = forms.some((f) => head(f) === "rec");
+    for (const form of forms) {
+        const p = parts(form);
+        if (p[0] !== "type")
+            continue;
+        if (p[1]?.startsWith("$") === true)
+            typeNames.set(p[1], types.length);
+        const body = p.find((item) => item.startsWith("("));
+        budget.reserve(256 + (body?.length ?? 0) * 6);
+        types.push(body !== undefined && head(body) === "func" && !typeSpaceUnknown
+            ? functionType(body, "func")
+            : null);
+    }
+    const signature = (form) => {
+        const p = parts(form);
+        const kind = p[0];
+        if (kind === "func" || kind === "tag") {
+            const use = p.find((t) => t.startsWith("(type "));
+            if (use === undefined)
+                return functionType(form, kind);
+            const reference = parts(use)[1];
+            const index = reference === undefined
+                ? undefined
+                : reference.startsWith("$")
+                    ? typeNames.get(reference)
+                    : Number(reference);
+            const type = index === undefined || typeSpaceUnknown ? undefined : types[index];
+            return type?.kind === "func" ? { ...type, kind } : null;
+        }
+        if (kind === "memory" || kind === "table") {
+            const groups = p.slice(1).filter((t) => t.startsWith("("));
+            let pageSize = "65536";
+            for (const group of groups) {
+                const declaration = parts(group);
+                if (kind !== "memory" ||
+                    declaration[0] !== "pagesize" ||
+                    declaration.length !== 2)
+                    return null;
+                const parsedPageSize = integer(declaration[1] ?? "");
+                if (parsedPageSize === null)
+                    return null;
+                pageSize = parsedPageSize;
+            }
+            const tokens = p
+                .slice(1)
+                .filter((t) => !t.startsWith("$") && !t.startsWith("("));
+            const address_type = tokens[0] === "i64" ? "i64" : "i32";
+            if (tokens[0] === "i64" || tokens[0] === "i32")
+                tokens.shift();
+            const minimum = integer(tokens.shift() ?? "");
+            const possibleMaximum = tokens[0] === undefined ? null : integer(tokens[0]);
+            if (possibleMaximum !== null)
+                tokens.shift();
+            const shared = tokens[0] === "shared";
+            if (shared)
+                tokens.shift();
+            if (minimum === null)
+                return null;
+            if (kind === "memory")
+                return tokens.length === 0
+                    ? {
+                        kind,
+                        page_size: pageSize,
+                        address_type,
+                        minimum,
+                        maximum: possibleMaximum,
+                        shared,
+                    }
+                    : null;
+            const element = tokens.shift();
+            return tokens.length === 0 &&
+                element !== undefined &&
+                (element === "funcref" || element === "externref")
+                ? {
+                    kind,
+                    address_type,
+                    minimum,
+                    maximum: possibleMaximum,
+                    shared,
+                    element,
+                }
+                : null;
+        }
+        if (kind === "global") {
+            const declaration = p[1]?.startsWith("$") === true ? p[2] : p[1];
+            const mutable = declaration?.startsWith("(mut ") === true;
+            const value_type = mutable && declaration !== undefined
+                ? parts(declaration)[1]
+                : declaration;
+            return value_type !== undefined && isValueType(value_type)
+                ? { kind, value_type, mutable }
+                : null;
+        }
+        return null;
+    };
+    const addDefinition = (form) => {
+        const p = parts(form);
+        const rawKind = p[0] ?? "unknown";
+        const kind = ["func", "table", "memory", "global", "tag"].includes(rawKind)
+            ? rawKind
+            : "unknown";
+        const space = definitions.get(kind) ?? [];
+        const item = {
+            signature: signature(form),
+            label: p[1]?.startsWith("$") === true ? p[1] : undefined,
+        };
+        budget.reserve(256);
+        const index = space.length;
+        space.push(item);
+        definitions.set(kind, space);
+        return { index, kind, signature: item.signature };
+    };
+    for (const form of forms) {
+        const p = parts(form);
+        if (p[0] !== "import")
+            continue;
+        const body = p[3];
+        if (body === undefined)
+            throw new Error("Incomplete WABT import");
+        const observed = addDefinition(body);
+        const entry = {
+            direction: "import",
+            module: name(p[1]),
+            name: name(p[2]),
+            ...observed,
+            wat_form: form,
+            issue: observed.signature === null
+                ? "Import type is outside admitted core signature semantics"
+                : null,
+        };
+        budget.reserve(wasmInterfaceEntryRepresentationBytes(entry));
+        result.entries.push(entry);
+    }
+    for (const form of forms) {
+        const kind = head(form);
+        if (kind !== undefined &&
+            ["func", "table", "memory", "global", "tag"].includes(kind))
+            addDefinition(form);
+    }
+    for (const form of forms) {
+        const p = parts(form);
+        if (p[0] !== "export")
+            continue;
+        const body = p[2];
+        if (body === undefined)
+            throw new Error("Incomplete WABT export");
+        const descriptor = parts(body);
+        const rawKind = descriptor[0] ?? "unknown";
+        const kind = ["func", "table", "memory", "global", "tag"].includes(rawKind)
+            ? rawKind
+            : "unknown";
+        const reference = descriptor[1];
+        const space = definitions.get(kind) ?? [];
+        const index = reference === undefined
+            ? -1
+            : reference.startsWith("$")
+                ? space.findIndex((d) => d.label === reference)
+                : Number(reference);
+        const observed = Number.isSafeInteger(index) && index >= 0 ? space[index] : undefined;
+        const entry = {
+            direction: "export",
+            module: null,
+            name: name(p[1]),
+            kind,
+            index: observed === undefined ? null : index,
+            signature: observed?.signature ?? null,
+            wat_form: form,
+            issue: observed?.signature == null
+                ? "Export type/index is outside admitted core signature semantics"
+                : null,
+        };
+        budget.reserve(wasmInterfaceEntryRepresentationBytes(entry));
+        result.entries.push(entry);
+    }
+    // Unsupported signatures leave inventory completeness intact. A missing
+    // signature is unknown per entry, not proof that a name is absent.
+    return result;
+};
+/** New typed coverage may be incomplete without discarding existing decoded WAT Evidence. */
+export const parseWabtInterface = (forms) => {
+    const result = { state: "complete", entries: [], issues: [] };
+    try {
+        return decodeWabtInterface(forms, result);
+    }
+    catch (cause) {
+        if (!(cause instanceof AnalysisResourceConstraintError))
+            throw cause;
+        result.state = "partial";
+        result.issues.push(cause.message);
+        return result;
+    }
+};

package/dist/wasm/WabtOutput.js

@@ -0,0 +1,60 @@
+/** WABT prints names with %.*s, so an embedded NUL ends their display. */
+const wabtDisplayedName = (name) => name?.split("\0", 1)[0];
+/** Frame WABT's raw custom names using the ordered names from its escaped WAT output. */
+export const parseWabtOutput = (text, artifactBytes, customSectionNames, debugModuleNames = []) => {
+    const preamble = "\nmodule.wasm:\tfile format wasm 0x1\n" +
+        debugModuleNames
+            .map((name) => `module name: <${wabtDisplayedName(name)}>\n`)
+            .join("");
+    const prefix = `${preamble}\nSections:\n\n`;
+    if (!text.startsWith(prefix))
+        throw new Error("Unsupported WABT section header format.");
+    let offset = prefix.length;
+    let customIndex = 0;
+    const sections = [];
+    while (!text.startsWith("\nSection Details:\n", offset)) {
+        const match = /^[ \t]*(\w+) start=0x([\da-f]+) end=0x([\da-f]+) \(size=0x([\da-f]+)\) /u.exec(text.slice(offset));
+        if (match === null)
+            throw new Error("Unrecognized WABT section row.");
+        offset += match[0].length;
+        let description;
+        if (match[1] === "Custom") {
+            const name = wabtDisplayedName(customSectionNames[customIndex++]);
+            if (name === undefined || !text.startsWith(`"${name}"\n`, offset))
+                throw new Error("WABT custom-section header does not match decoded WAT.");
+            description = `"${name}"`;
+            offset += description.length + 1;
+        }
+        else {
+            const end = text.indexOf("\n", offset);
+            if (end < 0)
+                throw new Error("Incomplete WABT section row.");
+            description = text.slice(offset, end).trim();
+            offset = end + 1;
+        }
+        const section = {
+            kind: match[1] ?? "",
+            start: Number.parseInt(match[2] ?? "", 16),
+            end: Number.parseInt(match[3] ?? "", 16),
+            bytes: Number.parseInt(match[4] ?? "", 16),
+            description,
+        };
+        const sectionHeaderBytes = section.start - (sections.at(-1)?.end ?? 8);
+        if (section.end > artifactBytes ||
+            section.end - section.start !== section.bytes ||
+            sectionHeaderBytes < 2 ||
+            sectionHeaderBytes > 6)
+            throw new Error("WABT section ranges do not match selected artifact.");
+        sections.push(section);
+    }
+    if (customIndex !== customSectionNames.length)
+        throw new Error("WABT custom-section inventory does not match decoded WAT.");
+    if ((sections.at(-1)?.end ?? 8) !== artifactBytes)
+        throw new Error("WABT section output does not cover the selected artifact.");
+    const separator = offset + 1;
+    return {
+        sections,
+        headers: text.slice(0, separator),
+        details: `${preamble.slice(1)}\n${text.slice(separator)}`,
+    };
+};

package/dist/wasm/WabtRelease.js

@@ -0,0 +1,12 @@
+/** Exact upstream release whose producer output is admitted by this adapter. */
+export const WABT_PROVIDER_IDENTITY = {
+    id: "wabt-artifact",
+    name: "REA WABT artifact adapter",
+    version: "wabt@1.0.42",
+};
+export const WABT_LIMITS = {
+    inputBytes: 8 * 1024 * 1024,
+    toolBytes: 64 * 1024 * 1024,
+    outputBytes: 32 * 1024 * 1024,
+    timeoutMs: 30_000,
+};

package/dist/wasm/WabtString.js

@@ -0,0 +1,48 @@
+/** Decode a producer WAT string to frame objdump's raw display text. */
+export const watString = (form, start) => {
+    let end = start;
+    while (end < form.length && form[end] !== '"') {
+        if (form[end] === "\\")
+            end++;
+        end++;
+    }
+    if (end === form.length)
+        throw new Error("Incomplete WABT custom-section name.");
+    const name = form.slice(start, end);
+    // Escapes shrink; literal UTF-8 has the same byte extent as its source.
+    const bytes = Buffer.alloc(Buffer.byteLength(name, "utf8"));
+    let length = 0;
+    for (let index = 0; index < name.length;) {
+        if (name[index] !== "\\") {
+            const next = name.indexOf("\\", index);
+            const end = next < 0 ? name.length : next;
+            length += bytes.write(name.slice(index, end), length, "utf8");
+            index = end;
+            continue;
+        }
+        const hex = name.slice(index + 1, index + 3);
+        if (/^[\da-f]{2}$/iu.test(hex)) {
+            bytes[length++] = Number.parseInt(hex, 16);
+            index += 3;
+        }
+        else {
+            const escape = name[index + 1];
+            const value = escape === "t"
+                ? 9
+                : escape === "n"
+                    ? 10
+                    : escape === "r"
+                        ? 13
+                        : escape === '"'
+                            ? 34
+                            : escape === "\\"
+                                ? 92
+                                : undefined;
+            if (value === undefined)
+                throw new Error("Unsupported WABT name escape.");
+            bytes[length++] = value;
+            index += 2;
+        }
+    }
+    return { bytes: bytes.subarray(0, length), end: end + 1 };
+};

package/dist/wasm/WabtWat.js

@@ -0,0 +1,147 @@
+import { parseWabtInterface } from "./WabtInterface.js";
+import { watString } from "./WabtString.js";
+/** Read only module-name metadata from WABT's preserved name-section payload. */
+const moduleNames = (bytes) => {
+    const names = [];
+    let offset = 0;
+    const uint32 = (end) => {
+        let value = 0;
+        for (let shift = 0; shift <= 28 && offset < end; shift += 7) {
+            const byte = bytes[offset++];
+            if (byte === undefined)
+                break;
+            if (shift === 28 && byte > 15)
+                break;
+            value += (byte & 127) * 2 ** shift;
+            if (byte < 128)
+                return value;
+        }
+        throw new Error("Incomplete WABT name-section metadata.");
+    };
+    while (offset < bytes.length) {
+        const type = uint32(bytes.length);
+        const size = uint32(bytes.length);
+        const end = offset + size;
+        if (end > bytes.length)
+            throw new Error("Incomplete WABT name-section metadata.");
+        if (type === 0 && size !== 0) {
+            const length = uint32(end);
+            if (offset + length !== end)
+                throw new Error("Incomplete WABT module-name metadata.");
+            names.push(new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes.subarray(offset, end)));
+        }
+        offset = end;
+    }
+    return names;
+};
+/** Extract exact top-level WABT WAT forms; no raw WASM decoding or import/export name unescaping. */
+export const parseWabtWat = (text) => {
+    if (!/^\(module(?:\s|\))/u.test(text))
+        throw new Error("Unsupported WABT WAT module prefix.");
+    const forms = [];
+    const imports = [];
+    const exports = [];
+    const customSectionNames = [];
+    const debugModuleNames = [];
+    let depth = 0;
+    let start = 0;
+    let quoted = false;
+    let commentDepth = 0;
+    let lineComment = false;
+    let closed = false;
+    for (let index = 0; index < text.length; index++) {
+        const char = text[index];
+        const next = text[index + 1];
+        if (lineComment) {
+            if (char === "\n")
+                lineComment = false;
+            continue;
+        }
+        if (quoted) {
+            if (char === "\\")
+                index++;
+            else if (char === '"')
+                quoted = false;
+            continue;
+        }
+        if (commentDepth > 0) {
+            if (char === "(" && next === ";") {
+                commentDepth++;
+                index++;
+            }
+            else if (char === ";" && next === ")") {
+                commentDepth--;
+                index++;
+            }
+            continue;
+        }
+        if (char === ";" && next === ";") {
+            lineComment = true;
+            index++;
+            continue;
+        }
+        if (char === "(" && next === ";") {
+            commentDepth++;
+            index++;
+            continue;
+        }
+        if (char === '"') {
+            if (depth === 0)
+                throw new Error("Unexpected string outside WABT WAT module.");
+            quoted = true;
+            continue;
+        }
+        if (char === "(") {
+            if (closed)
+                throw new Error("Unexpected second WABT WAT module.");
+            depth++;
+            if (depth === 2)
+                start = index;
+        }
+        else if (char === ")") {
+            if (depth === 2) {
+                const form = text.slice(start, index + 1);
+                if (/^\((?:type|rec|import|export|func|table|memory|global|tag)\s/u.test(form))
+                    forms.push(form);
+                if (/^\(import\s/u.test(form))
+                    imports.push(form);
+                else if (/^\(export\s/u.test(form))
+                    exports.push(form);
+                else if (/^\(@custom\s/u.test(form)) {
+                    const prefix = /^\(@custom\s+"/u.exec(form);
+                    if (prefix === null)
+                        throw new Error("Unsupported WABT custom-section name.");
+                    const nameString = watString(form, prefix[0].length);
+                    // A WASM name is length-delimited UTF-8; leading U+FEFF is name data.
+                    const name = new TextDecoder("utf-8", {
+                        fatal: true,
+                        ignoreBOM: true,
+                    }).decode(nameString.bytes);
+                    customSectionNames.push(name);
+                    if (name === "name") {
+                        const payloadPrefix = /^\s+"/u.exec(form.slice(nameString.end));
+                        if (payloadPrefix === null)
+                            throw new Error("Unsupported WABT name-section payload.");
+                        const payload = watString(form, nameString.end + payloadPrefix[0].length);
+                        debugModuleNames.push(...moduleNames(payload.bytes));
+                    }
+                }
+            }
+            if (--depth < 0)
+                throw new Error("Unbalanced WABT WAT output.");
+            if (depth === 0)
+                closed = true;
+        }
+        else if (depth === 0 && char !== undefined && !/\s/u.test(char))
+            throw new Error("Unexpected text outside WABT WAT module.");
+    }
+    if (depth !== 0 || quoted || commentDepth !== 0)
+        throw new Error("Incomplete WABT WAT output.");
+    return {
+        imports,
+        exports,
+        customSectionNames,
+        debugModuleNames,
+        interface: parseWabtInterface(forms),
+    };
+};

package/dist/wasm/WasmGlueAdapter.js

@@ -0,0 +1,53 @@
+import { basename, dirname, resolve } from "node:path";
+import * as t from "@babel/types";
+import { parseJavaScriptSource } from "../domain/javascript/javascriptSourceParser.js";
+import { traverseJavaScriptAst } from "../domain/javascript/javascriptSemanticTraversal.js";
+/** Associate visible literals with selected candidates without asserting data flow or URL identity. */
+export const associateWasmGlue = (source, path, candidates) => {
+    // Babel requires a hashbang at offset zero. Removing only its preceding BOM
+    // leaves reference coordinates intact: all code starts on a later line.
+    const file = parseJavaScriptSource(source.startsWith("\uFEFF#!") ? source.slice(1) : source);
+    const references = [];
+    if (file === null)
+        return { parse_status: "failed", references };
+    traverseJavaScriptAst(file, {
+        enter(node) {
+            const value = t.isStringLiteral(node)
+                ? node.value
+                : t.isTemplateLiteral(node) && node.expressions.length === 0
+                    ? node.quasis[0]?.value.cooked
+                    : undefined;
+            if (value === undefined ||
+                value === null ||
+                !/\.wasm(?:[?#].*)?$/iu.test(value) ||
+                node.loc == null)
+                return;
+            const stripped = value.split(/[?#]/u)[0] ?? value;
+            const local = !/^[a-z][a-z\d+.-]*:|^\/\//iu.test(value) &&
+                !value.startsWith("/") &&
+                !/[?#]/u.test(value);
+            const exact = local
+                ? candidates.filter((candidate) => candidate === resolve(dirname(path), value))
+                : [];
+            const matches = exact.length > 0
+                ? exact
+                : candidates.filter((candidate) => basename(candidate) === basename(stripped));
+            references.push({
+                value,
+                line: node.loc.start.line,
+                column: node.loc.start.column,
+                candidate_paths: [...matches],
+                association: exact.length > 0
+                    ? "local-path-candidate"
+                    : matches.length > 0
+                        ? "basename-candidates"
+                        : "unresolved",
+                evidence_kind: "static-literal",
+            });
+        },
+    });
+    return {
+        parse_status: file.errors.length === 0 ? "complete" : "partial",
+        references,
+    };
+};

package/dist/wasm/WasmInterfaceBudget.js

@@ -0,0 +1,11 @@
+import { AnalysisResourceConstraintError } from "../domain/analysisErrorCore.js";
+import { WASM_INTERFACE_REPRESENTATION_BYTES } from "../domain/wasm/wasmInterface.js";
+/** Eager typed observations share the existing WABT output capacity, not an agent token estimate. */
+export class WasmInterfaceBudget {
+    #remaining = WASM_INTERFACE_REPRESENTATION_BYTES;
+    reserve(bytes) {
+        if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > this.#remaining)
+            throw new AnalysisResourceConstraintError("inspect_wasm_artifact", "capacity", "Typed WASM interface decoding exceeds the WABT output representation budget", { maximum_bytes: WASM_INTERFACE_REPRESENTATION_BYTES });
+        this.#remaining -= bytes;
+    }
+}