rea-agents 6.2.0 → 6.3.0

package/dist/cli/streamedJsonOutput.js

@@ -1,18 +1,70 @@
+import { constants } from "node:buffer";
 import {} from "node:stream";
-import { Filter } from "incur";
+import { Cli, Filter } from "incur";
 import { parseCliOutputArguments } from "../cliOutput.js";
-import { writeJsonOutput } from "./jsonOutput.js";
+import { AnalysisResourceConstraintError } from "../domain/analysisErrorCore.js";
+import { projectAnalysisError, } from "../domain/analysisErrorProjection.js";
+import { jsonOutputParts, writeJsonOutput } from "./jsonOutput.js";
+const registeredCommands = Cli.toCommands;
+/** Install formatting once, after registration, for every ordinary CLI result. */
+export const streamCliCommandResults = (cli, output) => {
+    const commands = registeredCommands.get(cli);
+    if (commands !== undefined)
+        wrapCommands(commands, [], output);
+};
+const wrapCommands = (commands, parents, output) => {
+    for (const [name, entry] of commands) {
+        const path = [...parents, name];
+        if ("_group" in entry) {
+            wrapCommands(entry.commands, path, output);
+            if (entry.root !== undefined)
+                wrapCommand(entry.root, path.join(" "), output);
+        }
+        else if (!("_alias" in entry) && !("_fetch" in entry))
+            wrapCommand(entry, path.join(" "), output);
+    }
+};
+const wrapCommand = (command, name, output) => {
+    const run = command.run;
+    command.run = (context) => {
+        const started = performance.now();
+        const result = run(context);
+        // Generator results and Incur's sentinel responses retain their own protocol.
+        if (typeof result === "object" &&
+            result !== null &&
+            Symbol.asyncIterator in result)
+            return result;
+        return Promise.resolve(result).then(async (value) => {
+            if (typeof value === "object" &&
+                value !== null &&
+                Symbol.for("incur.sentinel") in value)
+                return value;
+            if (!(await output.write(value, {
+                command: name,
+                format: context.format,
+                duration: `${Math.round(performance.now() - started)}ms`,
+            })))
+                return value;
+            if (output.error !== undefined)
+                return context.error({
+                    code: output.error.code,
+                    message: output.error.message,
+                });
+            return undefined;
+        });
+    };
+};
 /** Preserve Incur's JSON controls while streaming the complete result. */
 export const createStreamedCliJsonOutput = (arguments_, destination) => {
     const options = parseCliOutputArguments(arguments_);
     if (options.parseError ||
-        options.tokenCount ||
         options.tokenWindow ||
         (options.format !== "json" && options.format !== "jsonl"))
         return undefined;
     const format = options.format;
     let handled = false;
     let failed = false;
+    let error;
     return {
         get handled() {
             return handled;
@@ -20,6 +72,9 @@ export const createStreamedCliJsonOutput = (arguments_, destination) => {
         get failed() {
             return failed;
         },
+        get error() {
+            return error;
+        },
         async write(value, metadata) {
             if (metadata.format !== format)
                 return false;
@@ -30,6 +85,26 @@ export const createStreamedCliJsonOutput = (arguments_, destination) => {
                 command: metadata.command,
                 duration: metadata.duration,
             };
+            if (options.tokenCount) {
+                // Incur/tokenx materialize the formatted value. Measure its UTF-16
+                // expansion before allowing that allocation, independently of UTF-8 bytes.
+                let characters = 0;
+                if (filtered !== undefined &&
+                    filtered !== null &&
+                    typeof filtered !== "function" &&
+                    typeof filtered !== "symbol")
+                    for (const part of jsonOutputParts(filtered, format))
+                        characters += part.length;
+                characters = Math.max(0, characters - 1);
+                if (characters <= constants.MAX_STRING_LENGTH)
+                    return false;
+                error = projectAnalysisError(new AnalysisResourceConstraintError(metadata.command, "memory", "Token counting requires a formatted string larger than the runtime permits.", {
+                    formatted_characters: characters,
+                    max_string_characters: constants.MAX_STRING_LENGTH,
+                }, {
+                    remediationAction: "Remove --token-count to stream the complete JSON result, or narrow it with --filter-output.",
+                }));
+            }
             const document = options.fullOutput
                 ? filtered === undefined
                     ? { ok: true, meta }
@@ -44,7 +119,11 @@ export const createStreamedCliJsonOutput = (arguments_, destination) => {
             // document from Incur's error formatter.
             handled = true;
             try {
-                await writeJsonOutput(document, destination, format);
+                await writeJsonOutput(error === undefined
+                    ? document
+                    : options.fullOutput
+                        ? { ok: false, error, meta }
+                        : error, destination, format);
             }
             catch (cause) {
                 failed = true;

package/dist/cli/utilityCommands.js

@@ -97,7 +97,7 @@ const invalidNativeUiScenarioInput = (operation, issues) => ({
     error: "Application workflow failed",
     ...projectAnalysisError(new AnalysisInputError(operation, undefined, issues)),
 });
-const registerCapabilityCommands = (cli, logger, { runProviderStatus, runCapabilityStatus, }) => {
+const registerCapabilityCommands = (cli, logger, { runSessionStatus }) => {
     for (const command of [
         CLI_COMMANDS.capabilities,
         CLI_COMMANDS.providers,
@@ -106,9 +106,7 @@ const registerCapabilityCommands = (cli, logger, { runProviderStatus, runCapabil
             description: command === "capabilities"
                 ? "List provider capabilities and side effects"
                 : "List configured analysis providers",
-            run: () => logCliCommand(logger, command, () => command === CLI_COMMANDS.providers
-                ? runProviderStatus(logger)
-                : runCapabilityStatus(logger)),
+            run: () => logCliCommand(logger, command, () => runSessionStatus(logger)),
         });
     }
 };

package/dist/cli.js

@@ -29,6 +29,7 @@ import { registerElectronCommands } from "./cli/electronCommands.js";
 import { registerJavaScriptRuntimeObservationCommands } from "./cliJavaScriptRuntimeCommands.js";
 import { registerApplicationCommands } from "./cli/applicationCommands.js";
 import { presentOmittableDefaults } from "./cli/omittableDefaults.js";
+import { streamCliCommandResults, } from "./cli/streamedJsonOutput.js";
 /**
  * Build the one-shot Incur CLI without starting Hopper at import time.
  * Analysis commands acquire and close their own sessions; bare `mcp` and
@@ -50,7 +51,7 @@ export const createCli = (selectedEnvironment = process.env, resultOutput) => {
         sync: false,
     });
     registerSetupCommands(cli, logger, environment);
-    registerCoreAnalysisCommands(cli, logger, analysis.runDirectAnalysis, resultOutput);
+    registerCoreAnalysisCommands(cli, logger, analysis.runDirectAnalysis);
     registerUtilityCommands(cli, logger, environment, analysis);
     registerEvmCommands(cli, logger, environment);
     registerArtifactCommands(cli, logger, analysis.runProviderAnalysis);
@@ -70,9 +71,11 @@ export const createCli = (selectedEnvironment = process.env, resultOutput) => {
     registerJavaScriptRecoveryCommands(cli, logger, environment);
     registerAdvancedBrowserCommands(cli, logger);
     registerBrowserScenarioCommands(cli, logger, environment);
-    registerElectronCommands(cli, logger, environment, resultOutput);
+    registerElectronCommands(cli, logger, environment);
     registerJavaScriptRuntimeObservationCommands(cli, logger);
     registerApplicationCommands(cli, logger);
     presentOmittableDefaults(cli);
+    if (resultOutput !== undefined)
+        streamCliCommandResults(cli, resultOutput);
     return cli;
 };

package/dist/cliJsonFile.js

@@ -0,0 +1,179 @@
+import { constants } from "node:buffer";
+import { pipeline } from "node:stream/promises";
+import { getHeapStatistics } from "node:v8";
+import parser from "stream-json/parser.js";
+import streamValues from "stream-json/streamers/stream-values.js";
+import { withRegularFile } from "./application/RegularFileRead.js";
+import { JSON_INPUT_RESOURCE_REMEDIATION, parseUtf8Json, } from "./application/Utf8JsonInput.js";
+import { AnalysisInputError, AnalysisResourceConstraintError, } from "./domain/analysisErrorCore.js";
+import { err, ok } from "./domain/result.js";
+const READ_CHUNK_BYTES = 64 * 1024;
+const PACKED_STRING_PART_CODE_UNITS = 64 * 1024;
+// Retain native-parser speed for modest inputs while bounding its extra copies.
+// This selects an implementation; larger files remain accepted through streaming.
+const NATIVE_PARSE_READ_BUDGET = 8 * 1024 * 1024;
+/** Parse strict UTF-8 JSON without requiring a whole-document string. */
+export const readCliJsonFile = (path, operation, signal) => withRegularFile(path, async (handle, stats) => {
+    let found = false;
+    let value;
+    try {
+        const prefix = stats.size <= NATIVE_PARSE_READ_BUDGET
+            ? await readPrefix(handle, stats.size + 1, signal)
+            : undefined;
+        if (prefix?.complete === true) {
+            const parsed = parseUtf8Json(prefix.bytes, operation, path, "cli-json-input");
+            return parsed.ok
+                ? ok(parsed.value)
+                : err(invalidJson(operation, parsed.error, parsed.cause));
+        }
+        await pipeline(decodedChunks(handle, signal, prefix?.bytes), parser.asStream({
+            jsonStreaming: false,
+            streamValues: false,
+            packKeys: false,
+            packStrings: false,
+        }), packJsonStrings(operation, stats.size), streamValues.asStream(), async (rows) => {
+            for await (const row of rows) {
+                if (found ||
+                    typeof row !== "object" ||
+                    row === null ||
+                    !("key" in row) ||
+                    row.key !== 0 ||
+                    !("value" in row))
+                    throw new Error("Unexpected JSON parser result");
+                found = true;
+                value = row.value;
+            }
+        }, signal === undefined ? {} : { signal });
+        return found
+            ? ok(value)
+            : err(invalidJson(operation, "JSON document is empty"));
+    }
+    catch (cause) {
+        if (cause instanceof AnalysisResourceConstraintError)
+            return err(cause);
+        if (cause instanceof TypeError &&
+            "code" in cause &&
+            cause.code === "ERR_ENCODING_INVALID_ENCODED_DATA")
+            return err(invalidJson(operation, "JSON input is not valid UTF-8", cause));
+        if (cause instanceof SyntaxError ||
+            (cause instanceof Error && cause.message.startsWith("Parser ")))
+            return err(invalidJson(operation, cause.message, cause));
+        if (cause instanceof Error &&
+            ((cause instanceof RangeError &&
+                cause.message === "Invalid string length") ||
+                ("code" in cause && cause.code === "ERR_STRING_TOO_LONG")))
+            return err(new AnalysisResourceConstraintError(operation, "memory", "An individual JSON string exceeds the runtime string limit", {
+                input_file_bytes: stats.size,
+                max_string_code_units: constants.MAX_STRING_LENGTH,
+            }, {
+                cause,
+                remediationAction: JSON_INPUT_RESOURCE_REMEDIATION,
+            }));
+        throw cause;
+    }
+}, signal);
+const packJsonStrings = (operation, inputFileBytes) => async function* (tokens) {
+    let kind;
+    let length = 0;
+    let value = "";
+    let parts = [];
+    let partLength = 0;
+    for await (const token of tokens) {
+        if (typeof token !== "object" || token === null || !("name" in token))
+            throw new Error("Unexpected JSON parser token");
+        switch (token.name) {
+            case "startKey":
+            case "startString":
+                kind = token.name === "startKey" ? "keyValue" : "stringValue";
+                break;
+            case "stringChunk":
+                if (kind === undefined ||
+                    !("value" in token) ||
+                    typeof token.value !== "string")
+                    throw new Error("Unexpected JSON string fragment");
+                length += token.value.length;
+                if (length > constants.MAX_STRING_LENGTH)
+                    throw new RangeError("Invalid string length");
+                parts.push(token.value);
+                partLength += token.value.length;
+                if (partLength >= PACKED_STRING_PART_CODE_UNITS) {
+                    // The tokenizer emits short fragments. Coalesce them before retaining
+                    // a string so millions of substring/rope nodes cannot exhaust the heap
+                    // before the native string-length constraint can be reported.
+                    requireStringAssemblyHeadroom(operation, inputFileBytes, length);
+                    value += parts.join("");
+                    parts = [];
+                    partLength = 0;
+                }
+                break;
+            case "endKey":
+            case "endString":
+                if (kind === undefined)
+                    throw new Error("Unexpected JSON string end");
+                requireStringAssemblyHeadroom(operation, inputFileBytes, length);
+                yield { name: kind, value: value + parts.join("") };
+                kind = undefined;
+                length = 0;
+                value = "";
+                parts = [];
+                partLength = 0;
+                break;
+            default:
+                yield token;
+        }
+    }
+};
+const requireStringAssemblyHeadroom = (operation, inputFileBytes, stringCodeUnits) => {
+    if (stringCodeUnits < PACKED_STRING_PART_CODE_UNITS)
+        return;
+    const heap = getHeapStatistics();
+    // Concatenation or key interning may flatten the retained rope. Reserve its
+    // UTF-16 representation and the next coalesced part before that allocation.
+    const requiredBytes = 2 * (stringCodeUnits + PACKED_STRING_PART_CODE_UNITS);
+    if (requiredBytes > heap.total_available_size)
+        throw new AnalysisResourceConstraintError(operation, "memory", "Insufficient heap headroom to assemble a complete JSON string", {
+            input_file_bytes: inputFileBytes,
+            string_code_units: stringCodeUnits,
+            string_assembly_headroom_bytes: requiredBytes,
+            available_heap_bytes: heap.total_available_size,
+            heap_size_limit_bytes: heap.heap_size_limit,
+        }, {
+            remediationAction: JSON_INPUT_RESOURCE_REMEDIATION,
+        });
+};
+async function* decodedChunks(handle, signal, prefix) {
+    const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+    if (prefix !== undefined)
+        for (let offset = 0; offset < prefix.length; offset += READ_CHUNK_BYTES) {
+            signal?.throwIfAborted();
+            yield decoder.decode(prefix.subarray(offset, offset + READ_CHUNK_BYTES), {
+                stream: true,
+            });
+        }
+    const bytes = Buffer.allocUnsafe(READ_CHUNK_BYTES);
+    while (true) {
+        signal?.throwIfAborted();
+        const read = await handle.read(bytes, 0, bytes.length, null);
+        signal?.throwIfAborted();
+        if (read.bytesRead === 0)
+            break;
+        yield decoder.decode(bytes.subarray(0, read.bytesRead), { stream: true });
+    }
+    yield decoder.decode();
+}
+const readPrefix = async (handle, size, signal) => {
+    const bytes = Buffer.allocUnsafe(size);
+    let offset = 0;
+    while (offset < bytes.length) {
+        signal?.throwIfAborted();
+        const read = await handle.read(bytes, offset, bytes.length - offset, null);
+        signal?.throwIfAborted();
+        if (read.bytesRead === 0)
+            return { bytes: bytes.subarray(0, offset), complete: true };
+        offset += read.bytesRead;
+    }
+    // The file grew after admission. Continue from this same handle, preserving
+    // the prefix already read rather than reopening or dropping its bytes.
+    return { bytes, complete: false };
+};
+const invalidJson = (operation, message, cause) => new AnalysisInputError(operation, cause === undefined ? undefined : { cause }, [{ path: [], reason: "invalid_format", expected: "JSON", message }]);

package/dist/cliJsonInput.js

@@ -1,29 +1,52 @@
-import { readFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { AnalysisInputError } from "./domain/analysisErrorCore.js";
+import { readCliJsonFile } from "./cliJsonFile.js";
+import { NonRegularFileReadError } from "./filesystem/RegularFile.js";
+import { AnalysisAccessDeniedError, AnalysisInputError, } from "./domain/analysisErrorCore.js";
 import { projectAnalysisError } from "./domain/analysisErrorProjection.js";
 import { safeParseJson } from "./domain/safeJson.js";
 /** Parse inline JSON or one local JSON file for a CLI workflow. */
 export const parseCliJsonInput = async (value, operation) => {
-    const inline = parseJson(value);
-    if (inline !== undefined)
-        return { ok: true, value: inline };
+    const inline = safeParseJson(value);
+    if (inline.ok)
+        return { ok: true, value: inline.value };
     try {
-        // Read raw bytes so invalid UTF-8 is rejected by parseJson instead of
-        // being silently replaced by lossy "utf8" decoding.
-        const parsed = parseJson(await readFile(value));
-        return parsed === undefined
-            ? jsonFileError(value, operation, "invalid-json")
-            : { ok: true, value: parsed };
+        const parsed = await readCliJsonFile(value, operation);
+        return parsed.ok
+            ? { ok: true, value: parsed.value }
+            : {
+                ok: false,
+                error: {
+                    error: "Application workflow failed",
+                    ...projectAnalysisError(parsed.error),
+                    input_path: value,
+                    input_reason: parsed.error._tag === "AnalysisInputError"
+                        ? "invalid-json"
+                        : "too-large",
+                },
+            };
     }
     catch (cause) {
+        const systemCode = accessDeniedSystemCode(cause);
+        if (systemCode !== undefined)
+            return jsonAccessDeniedError(value, operation, systemCode, cause);
         if (["{", "["].includes(value.trimStart()[0] ?? "") &&
             cannotBeAnExistingFile(cause) &&
             !hasExplicitJsonFileExtension(value))
             return { ok: false, error: inputError(operation) };
+        if (!(cause instanceof Error) ||
+            !("code" in cause) ||
+            typeof cause.code !== "string")
+            throw cause;
         return jsonFileError(value, operation, "read-failed", cause);
     }
 };
+const accessDeniedSystemCode = (cause) => {
+    if (!(cause instanceof Error) || !("code" in cause))
+        return undefined;
+    return cause.code === "EACCES" || cause.code === "EPERM"
+        ? cause.code
+        : undefined;
+};
 /**
  * Resolve named string fields of CLI-supplied JSON against the operator
  * working directory. Each entry is a key path from the document root; only
@@ -62,27 +85,6 @@ const cannotBeAnExistingFile = (cause) => typeof cause === "object" &&
         cause.code === "ENAMETOOLONG" ||
         cause.code === "ENOTDIR");
 const hasExplicitJsonFileExtension = (value) => value.toLowerCase().endsWith(".json");
-const parseJson = (value) => {
-    let text;
-    if (typeof value === "string") {
-        text = value;
-    }
-    else {
-        try {
-            text = new TextDecoder("utf-8", {
-                fatal: true,
-                ignoreBOM: true,
-            }).decode(value);
-        }
-        catch (cause) {
-            // Decoding failure means the bytes are not valid UTF-8 JSON input.
-            void cause;
-            return undefined;
-        }
-    }
-    const parsed = safeParseJson(text);
-    return parsed.ok ? parsed.value : undefined;
-};
 const inputError = (operation) => ({
     error: "Application workflow failed",
     ...projectAnalysisError(new AnalysisInputError(operation, undefined, [
@@ -100,7 +102,16 @@ const jsonFileError = (path, operation, reason, cause) => ({
         input_reason: reason,
     },
 });
-/** Name the system error so the caller can tell a typo from a permission denial. */
+const jsonAccessDeniedError = (path, operation, systemCode, cause) => ({
+    ok: false,
+    error: {
+        error: "Application workflow failed",
+        ...projectAnalysisError(new AnalysisAccessDeniedError(operation, path, systemCode, { cause })),
+        input_path: path,
+        input_reason: "read-failed",
+    },
+});
+/** Preserve file-selection and system failures alongside the requested path. */
 const readFailureIssue = (path, cause) => {
     const code = typeof cause === "object" &&
         cause !== null &&
@@ -111,6 +122,8 @@ const readFailureIssue = (path, cause) => {
     return {
         path: [],
         reason: "invalid_value",
-        message: `The JSON input file could not be read${code}: ${path ?? ""}`,
+        message: cause instanceof NonRegularFileReadError && cause.code === "ENOTFILE"
+            ? `The JSON input must be a regular file${code}: ${path ?? ""}`
+            : `The JSON input file could not be read${code}: ${path ?? ""}`,
     };
 };

package/dist/cliObservationOptions.js

@@ -57,4 +57,8 @@ export const javascriptApplicationOptions = z.object({
         .enum(["auto", "asar", "directory"])
         .default("auto")
         .describe("Application artifact format"),
+    integrityPolicy: z
+        .enum(["fail", "record-and-continue"])
+        .default("fail")
+        .describe("Behavior when declared application integrity does not match"),
 });

package/dist/composition/auxiliaryAnalysisProviders.js

@@ -1,13 +1,14 @@
 import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
-import { ARTIFACT_PROVIDER_IDENTITY, artifactCapabilities, } from "../artifacts/ArtifactProviderMetadata.js";
-import { MANAGED_STATIC_PROVIDER_IDENTITY, managedStaticCapabilities, } from "../dotnet/ManagedStaticProviderMetadata.js";
+import { artifactCapabilities } from "../artifacts/ArtifactProviderMetadata.js";
+import { ARTIFACT_GRAPH_PROVIDER, MANAGED_STATIC_PROVIDER, } from "../application/InvestigationProviders.js";
+import { managedStaticCapabilities } from "../dotnet/ManagedStaticProviderMetadata.js";
 import { NATIVE_MACOS_PROVIDER_IDENTITY, nativeMacOSCapabilities, } from "../native/NativeMacOSProviderMetadata.js";
 /** Wire the three existing auxiliary AnalysisProvider implementations lazily. */
 export const auxiliaryAnalysisProviderDeclarations = (selectedEnvironment, platform = process.platform) => {
     const environment = snapshotEnvironment(selectedEnvironment, platform);
     return [
         {
-            identity: ARTIFACT_PROVIDER_IDENTITY,
+            identity: ARTIFACT_GRAPH_PROVIDER,
             capabilities: artifactCapabilities(platform),
             load: async () => {
                 const { ArtifactProvider } = await import("../artifacts/ArtifactProvider.js");
@@ -23,7 +24,7 @@ export const auxiliaryAnalysisProviderDeclarations = (selectedEnvironment, platf
             },
         },
         {
-            identity: MANAGED_STATIC_PROVIDER_IDENTITY,
+            identity: MANAGED_STATIC_PROVIDER,
             capabilities: managedStaticCapabilities(),
             load: async () => {
                 const { ManagedStaticProvider } = await import("../dotnet/ManagedStaticProvider.js");

package/dist/composition/browserScenario.js

@@ -1,4 +1,4 @@
 import { PlaywrightBrowserScenarioProvider } from "../browser/PlaywrightBrowserScenarioProvider.js";
-import { PlaywrightScenarioSessionFactory } from "../browser/PlaywrightScenarioSession.js";
+import { PlaywrightScenarioSession } from "../browser/PlaywrightScenarioSession.js";
 /** Construct a fresh provider without opening a target or acquiring an engine. */
-export const createBrowserScenarioProvider = (environment) => new PlaywrightBrowserScenarioProvider(new PlaywrightScenarioSessionFactory(environment));
+export const createBrowserScenarioProvider = (environment) => new PlaywrightBrowserScenarioProvider((scenario, options) => PlaywrightScenarioSession.open(scenario, environment, options));

package/dist/composition/directAnalysis.js

@@ -1,7 +1,7 @@
 import { snapshotEnvironment } from "../process/snapshotEnvironment.js";
 import { parseConfig } from "../config/parseConfig.js";
 import { runDirectAnalysis as executeDirectAnalysis, runProviderAnalysis as executeProviderAnalysis, runManagedProviderExecution as executeManagedProvider, } from "../application/DirectAnalysis.js";
-import { runCapabilityStatus as executeCapabilityStatus, runProviderStatus as executeProviderStatus, } from "../application/DirectAnalysisStatus.js";
+import { runSessionStatus as executeSessionStatus } from "../application/DirectAnalysisStatus.js";
 import { createBinarySession, createManagedBinarySession } from "./binary.js";
 /** Bind one-shot analysis and status commands to one caller-selected environment. */
 export const createDirectAnalysis = (selectedEnvironment) => {
@@ -14,8 +14,7 @@ export const createDirectAnalysis = (selectedEnvironment) => {
     return {
         runDirectAnalysis: executeDirectAnalysis.bind(undefined, dependencies),
         runProviderAnalysis: executeProviderAnalysis.bind(undefined, dependencies),
-        runProviderStatus: executeProviderStatus.bind(undefined, dependencies),
-        runCapabilityStatus: executeCapabilityStatus.bind(undefined, dependencies),
+        runSessionStatus: executeSessionStatus.bind(undefined, dependencies),
     };
 };
 /** Execute managed metadata without configuration or native provider candidates. */

package/dist/contracts/artifactComparisonExample.js

@@ -1,10 +1,10 @@
-import { canonicalDigest } from "../domain/comparisonSemantics.js";
+import { digestCanonicalValue } from "../domain/canonicalDigest.js";
 import { createEvidence } from "../domain/evidence.js";
 import { jsonValueSchema } from "../domain/jsonValue.js";
 const inventory = (digit) => {
     const sha = digit.repeat(64);
-    const artifactId = `art_${canonicalDigest({ sha256: sha }, "Artifact example")}`;
-    const occurrenceId = `occ_${canonicalDigest({ root: artifactId }, "Artifact example")}`;
+    const artifactId = `art_${digestCanonicalValue({ sha256: sha }, "Artifact example")}`;
+    const occurrenceId = `occ_${digestCanonicalValue({ root: artifactId }, "Artifact example")}`;
     const nodes = [
         {
             artifact_id: artifactId,
@@ -35,7 +35,7 @@ const inventory = (digit) => {
             limitations: [],
         },
     ];
-    const graphSha256 = canonicalDigest({
+    const graphSha256 = digestCanonicalValue({
         nodes,
         occurrences,
         edges: [],
@@ -43,7 +43,7 @@ const inventory = (digit) => {
     }, "Artifact example");
     return jsonValueSchema.parse({
         manifest: {
-            manifest_id: `agm_${canonicalDigest({
+            manifest_id: `agm_${digestCanonicalValue({
                 root_artifact_id: artifactId,
                 graph_sha256: graphSha256,
             }, "Artifact example")}`,

package/dist/contracts/errorSchemas.js

@@ -68,7 +68,9 @@ export const analysisCliErrorEnvelopeSchema = z
     .object({
     error: z.string().min(1),
     input_path: z.string().optional(),
-    input_reason: z.enum(["invalid-json", "read-failed"]).optional(),
+    input_reason: z
+        .enum(["invalid-json", "read-failed", "too-large"])
+        .optional(),
 })
     .passthrough()
     .superRefine((value, context) => {

package/dist/contracts/functionComparisonExample.js

@@ -5,6 +5,11 @@ const dossier = (text) => jsonValueSchema.parse({
     procedure: {
         address: "0x1000",
         name: "main",
+        classification: null,
+        body: {
+            available: false,
+            reason: "The fixture omits function-body extent observations.",
+        },
         signature: "int main(void)",
         locals: [],
     },
@@ -18,6 +23,9 @@ const dossier = (text) => jsonValueSchema.parse({
     referenced_strings: [],
     referenced_names: [],
     basic_blocks: [{ start: "0x1000", end: "0x1001", successors: [] }],
+    native_api: null,
+    native_value_flow: null,
+    limitations: ["The fixture omits native API and value-flow observations."],
 });
 const observe = (digit, text) => createEvidence({
     path: `/tmp/function-${digit}`,