rea-agents 4.1.0 → 5.0.0

package/dist/domain/hopperValues.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { err, ok } from "./result.js";
-import { nativeApiBoundarySchema } from "./nativeApiBoundary.js";
-import { nativeValueFlowSchema } from "./nativeValueFlow.js";
+import { nativeApiBoundarySchema } from "./native/nativeApiBoundary.js";
+import { nativeValueFlowSchema } from "./native/nativeValueFlow.js";
 import { AnalysisOutputError } from "./analysisErrorCore.js";
 import { HopperProtocolError } from "./hopperErrors.js";
 /** Return a bounded byte distance between canonical addresses in one space. */

package/dist/domain/inputIssueProjection.js

@@ -2,8 +2,11 @@
 export const projectInputIssues = (issues, input) => issues.flatMap((issue) => projectIssue(issue, input));
 const projectIssue = (issue, input) => {
     const path = issue.path.flatMap((part) => typeof part === "string" || typeof part === "number" ? [part] : []);
+    // Branch issue paths are relative to the union; branches often agree.
     if (issue.code === "invalid_union")
-        return issue.errors.flatMap((branch) => branch.flatMap((branchIssue) => projectIssue(branchIssue, input)));
+        return uniqueIssues(issue.errors.flatMap((branch) => branch.flatMap((branchIssue) => projectIssue({ ...branchIssue, path: [...issue.path, ...branchIssue.path] }, input))));
+    if (issue.code === "invalid_key")
+        return issue.issues.flatMap((keyIssue) => projectIssue({ ...keyIssue, path: [...issue.path, ...keyIssue.path] }, input));
     if (issue.code === "unrecognized_keys")
         return issue.keys.map((key) => ({
             path: [...path, key],
@@ -24,7 +27,16 @@ const projectIssue = (issue, input) => {
     if (issue.code === "too_big")
         return [boundedIssue(path, "maximum", numericBound(issue.maximum))];
     if (issue.code === "invalid_format")
-        return [{ path, reason: "invalid_format", expected: issue.format }];
+        return [
+            {
+                path,
+                reason: "invalid_format",
+                expected: issue.format,
+                ...(issue.format === "regex" && issue.message.length > 0
+                    ? { message: issue.message }
+                    : {}),
+            },
+        ];
     if (issue.code === "invalid_value")
         return [
             {
@@ -41,6 +53,9 @@ const projectIssue = (issue, input) => {
         },
     ];
 };
+const uniqueIssues = (issues) => [
+    ...new Map(issues.map((issue) => [JSON.stringify(issue), issue])).values(),
+];
 const valueAtPath = (input, path) => {
     let current = input;
     for (const part of path) {

package/dist/domain/{electronObservation.js → javascript/electronObservation.js}

@@ -1,8 +1,9 @@
 import { z } from "zod";
-import { browserCompletenessSchema } from "./browserCompleteness.js";
-import { browserEndpointSchema } from "./browserObservation.js";
-import { webTextArtifactSchema } from "./webContentArtifact.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { browserCompletenessSchema } from "../browserCompleteness.js";
+import { browserEndpointSchema } from "../browserObservation.js";
+import { browserVersionSchema } from "../browserObservationSchemas.js";
+import { webTextArtifactSchema } from "../webContentArtifact.js";
+import { prefixedDigestSchema } from "../digests.js";
 const approvedElectronInput = {
     cdp_endpoint: browserEndpointSchema,
 };
@@ -26,13 +27,6 @@ export const inspectElectronPageInputSchema = z.union([
         include_script_sources: z.literal(true),
     }),
 ]);
-const browserVersionSchema = z.object({
-    product: z.string(),
-    protocol_version: z.string(),
-    revision: z.string(),
-    user_agent: z.string(),
-    js_version: z.string(),
-});
 const electronTargetSchema = z.object({
     target_id: z.string(),
     type: z.string(),

package/dist/domain/{electronStaticAnalysisBrowser.js → javascript/electronStaticAnalysisBrowser.js}

@@ -1,8 +1,9 @@
 import * as t from "@babel/types";
 import { boundedExpression, collectContextBridgeMembers, electronStaticValue, objectProperty, } from "./electronStaticAnalysisValues.js";
-import { compareCodePoints } from "./canonicalOrdering.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 import { addLocatedFinding } from "./javascriptStaticAnalysisFindings.js";
-import { argumentNode, calleeName, propertyName, range, staticPath, staticPathResolutionContext, } from "./javascriptStaticAnalysisHelpers.js";
+import { argumentNode, calleeName, range, staticPath, staticPathResolutionContext, } from "./javascriptStaticAnalysisHelpers.js";
+import { semanticStaticPropertyName } from "./javascriptAstValues.js";
 /** Inspect BrowserWindow, contextBridge, and utility-process syntax. */
 export const inspectElectronBrowserNode = (node, context) => {
     if (t.isNewExpression(node))
@@ -66,7 +67,7 @@ const collectWebPreferences = (source, object) => {
             });
             continue;
         }
-        const name = propertyName(property.key);
+        const name = semanticStaticPropertyName(property.key, property.computed);
         if (name === "" || property.computed) {
             unknown += 1;
             preferences.push({

package/dist/domain/{electronStaticAnalysisIpc.js → javascript/electronStaticAnalysisIpc.js}

@@ -1,7 +1,7 @@
 import * as t from "@babel/types";
 import { boundedExpression, electronStaticValue, handlerKind, } from "./electronStaticAnalysisValues.js";
 import { addLocatedFinding } from "./javascriptStaticAnalysisFindings.js";
-import { argumentNode, calleeName, propertyName, range, } from "./javascriptStaticAnalysisHelpers.js";
+import { argumentNode, calleeName, range, semanticStaticPropertyName, } from "./javascriptStaticAnalysisHelpers.js";
 /** Inspect Electron IPC operations and validation candidates. */
 export const inspectElectronIpcNode = (node, context) => {
     if (t.isCallExpression(node)) {
@@ -90,7 +90,7 @@ const inspectValidationCall = (node, context) => {
     if (!t.isMemberExpression(node.callee) &&
         !t.isOptionalMemberExpression(node.callee))
         return;
-    const method = propertyName(node.callee.property);
+    const method = semanticStaticPropertyName(node.callee.property, node.callee.computed);
     if (!["startsWith", "endsWith", "includes"].includes(method))
         return;
     const subject = t.isNode(node.callee.object)

package/dist/domain/{electronStaticAnalysisNative.js → javascript/electronStaticAnalysisNative.js}

@@ -1,7 +1,8 @@
 import * as t from "@babel/types";
-import { compareCodePoints } from "./canonicalOrdering.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
+import { stripQueryAndFragment } from "../artifactPathSyntax.js";
 import { addLocatedFinding } from "./javascriptStaticAnalysisFindings.js";
-import { argumentNode, calleeName, propertyName, range, stringValue, } from "./javascriptStaticAnalysisHelpers.js";
+import { argumentNode, calleeName, propertyName, range, semanticStaticPropertyName, stringValue, } from "./javascriptStaticAnalysisHelpers.js";
 /** Inspect JavaScript-side imports and re-exports of native .node addons. */
 export const inspectElectronNativeNode = (node, context) => {
     if (t.isImportDeclaration(node))
@@ -113,14 +114,14 @@ const addBinding = (input) => {
     });
 };
 const nativeRequire = (node) => {
-    if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
-        const nested = t.isNode(node.object)
-            ? nativeRequire(node.object)
-            : undefined;
-        if (nested === undefined)
+    let member = null;
+    while (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
+        if (!t.isNode(node.object))
             return undefined;
-        const member = propertyName(node.property);
-        return { ...nested, member: member === "" ? nested.member : member };
+        const property = semanticStaticPropertyName(node.property, node.computed);
+        if (member === null && property !== "")
+            member = property;
+        node = node.object;
     }
     if (!t.isCallExpression(node))
         return undefined;
@@ -131,7 +132,7 @@ const nativeRequire = (node) => {
         return undefined;
     const specifier = stringValue(argumentNode(node.arguments[0]));
     return specifier !== undefined && isNativeSpecifier(specifier, "require")
-        ? { specifier, member: null }
+        ? { specifier, member }
         : undefined;
 };
 const bindingMembers = (pattern) => {
@@ -160,8 +161,6 @@ const exportedMember = (node) => {
     return undefined;
 };
 const isNativeSpecifier = (specifier, moduleKind) => {
-    const path = moduleKind === "require"
-        ? specifier
-        : (specifier.split("#", 1)[0]?.split("?", 1)[0] ?? "");
+    const path = moduleKind === "require" ? specifier : stripQueryAndFragment(specifier);
     return path.toLowerCase().endsWith(".node");
 };

package/dist/domain/javascript/electronStaticAnalysisTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/{electronStaticAnalysisValues.js → javascript/electronStaticAnalysisValues.js}

@@ -1,7 +1,7 @@
 import * as t from "@babel/types";
-import { compareCodePoints } from "./canonicalOrdering.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 import { semanticStaticPropertyName } from "./javascriptAstValues.js";
-import { propertyName, sourceSlice, } from "./javascriptStaticAnalysisHelpers.js";
+import { sourceSlice } from "./javascriptStaticAnalysisHelpers.js";
 /** Preserve one literal value or the exact inert expression. */
 export const electronStaticValue = (source, node) => {
     const literal = literalValue(node);
@@ -89,7 +89,7 @@ const collectMembersAt = (object, prefix, depth, state) => {
             state.unknown += 1;
             continue;
         }
-        const name = propertyName(property.key);
+        const name = semanticStaticPropertyName(property.key, property.computed);
         if (name === "" || property.computed) {
             state.unknown += 1;
             continue;

package/dist/domain/{javascriptApplicationAnalysis.js → javascript/javascriptApplicationAnalysis.js}

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import { javascriptApplicationGraphSchema } from "./javascriptApplicationGraph.js";
 import { javaScriptSemanticGraphSchema } from "./javascriptSemanticGraph.js";
-import { digestSchema } from "./../domain/digests.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { digestSchema } from "../digests.js";
+import { prefixedDigestSchema } from "../digests.js";
 const countSchema = z.number().int().min(0);
 /** Public target-free request for static JavaScript application analysis. */
 export const analyzeJavaScriptApplicationInputSchema = z.strictObject({

package/dist/domain/{javascriptApplicationChangeGraph.js → javascript/javascriptApplicationChangeGraph.js}

@@ -1,5 +1,5 @@
 import { createJavaScriptApplicationEdge, createJavaScriptApplicationGraph, createJavaScriptApplicationNode, } from "./javascriptApplicationGraph.js";
-import { compareCodePoints, uniqueSorted } from "./canonicalOrdering.js";
+import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
 /** Merge compared nodes and add inferred right-to-left changed_from edges. */
 export const buildJavaScriptApplicationChangeGraph = (input) => {
     const allNodes = nodeCandidates(input);

package/dist/domain/{javascriptApplicationEvidenceSchemas.js → javascript/javascriptApplicationEvidenceSchemas.js}

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { digestSchema } from "./../domain/digests.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { digestSchema } from "../digests.js";
+import { prefixedDigestSchema } from "../digests.js";
 const boundedTextSchema = z.string().min(1);
 const boundedKeySchema = z.string().min(1);
 const unsafePathSegments = new Set(["", ".", ".."]);
@@ -345,7 +345,8 @@ export const applicationNodeIdentitySchema = z.discriminatedUnion("strategy", [
         strategy: z.literal("source-map-original"),
         stability: z.literal("source-map-exact"),
         source_map_sha256: digestSchema,
-        original_source: boundedTextSchema,
+        // The exact `sources` entry; `""` is a legal relative reference.
+        original_source: z.string(),
         source_sha256: digestSchema.nullable(),
     }),
     z.strictObject({
@@ -375,7 +376,8 @@ export const applicationNodeIdentitySchema = z.discriminatedUnion("strategy", [
         stability: z.literal("artifact-version"),
         artifact_sha256: digestSchema,
         namespace: boundedKeySchema,
-        key: boundedTextSchema,
+        // The exact artifact-local value, such as `""` from `fetch("")`.
+        key: z.string(),
     }),
     z.strictObject({
         strategy: z.literal("runtime-instance"),

package/dist/domain/{javascriptApplicationGraph.js → javascript/javascriptApplicationGraph.js}

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { canonicalDigest, canonicalJson } from "./comparisonSemantics.js";
-import { compareCodePoints, uniqueSorted } from "./canonicalOrdering.js";
+import { canonicalDigest, canonicalJson } from "../comparisonSemantics.js";
+import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
 import { applicationEdgeInputSchema, applicationEdgeSchema, applicationNodeInputSchema, applicationNodeObservationSchema, applicationNodeSchema, javascriptApplicationGraphInputSchema, javascriptApplicationGraphRecordSchema, } from "./javascriptApplicationGraphSchemas.js";
 const OBSERVATION_IDENTIFIER_STRATEGY = {
     strategy: "semantic-content-sha256",

package/dist/domain/{javascriptApplicationGraphSchemas.js → javascript/javascriptApplicationGraphSchemas.js}

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { applicationCoverageSchema, applicationGraphEvidenceSchema, applicationNodeIdentitySchema, } from "./javascriptApplicationEvidenceSchemas.js";
-import { jsonValueSchema } from "./jsonValue.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { jsonValueSchema } from "../jsonValue.js";
+import { prefixedDigestSchema } from "../digests.js";
 const boundedTextSchema = z.string().min(1);
 /** Node kinds admitted by JavaScript Application Graph. */
 export const JAVASCRIPT_APPLICATION_NODE_KINDS = [

package/dist/domain/{javascriptApplicationVersionComparison.js → javascript/javascriptApplicationVersionComparison.js}

@@ -1,5 +1,5 @@
-import { canonicalDigest } from "./comparisonSemantics.js";
-import { uniqueSorted } from "./canonicalOrdering.js";
+import { canonicalDigest } from "../comparisonSemantics.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
 import { buildJavaScriptApplicationChangeGraph } from "./javascriptApplicationChangeGraph.js";
 import { applicationVersionComparisonResultSchema, } from "./javascriptApplicationVersionComparisonSchemas.js";
 import { classifyJavaScriptApplicationVersions } from "./javascriptApplicationVersionItems.js";

package/dist/domain/{javascriptApplicationVersionComparisonSchemas.js → javascript/javascriptApplicationVersionComparisonSchemas.js}

@@ -1,9 +1,9 @@
 import { z } from "zod";
-import { emptyArraySchema } from "./emptyArraySchema.js";
-import { evidenceSchema } from "./evidence.js";
+import { emptyArraySchema } from "../emptyArraySchema.js";
+import { evidenceSchema } from "../evidence.js";
 import { javascriptApplicationGraphSchema } from "./javascriptApplicationGraph.js";
 import { JAVASCRIPT_APPLICATION_NODE_KINDS } from "./javascriptApplicationGraphSchemas.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { prefixedDigestSchema } from "../digests.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
 const nodeIdSchema = prefixedDigestSchema("jag_node");
 const textSchema = z.string().min(1);

package/dist/domain/{javascriptApplicationVersionItems.js → javascript/javascriptApplicationVersionItems.js}

@@ -1,5 +1,5 @@
-import { absenceClaimable, canonicalDigest, canonicalJson, } from "./comparisonSemantics.js";
-import { compareCodePoints } from "./canonicalOrdering.js";
+import { absenceClaimable, canonicalDigest, canonicalJson, } from "../comparisonSemantics.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 import {} from "./javascriptApplicationGraph.js";
 /** Classify matched, unmatched, and ambiguous nodes without inventing absence. */
 export const classifyJavaScriptApplicationVersions = (matching, context) => {

package/dist/domain/{javascriptApplicationVersionKeys.js → javascript/javascriptApplicationVersionKeys.js}

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "./canonicalOrdering.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 const matchTiers = () => [
     {
         match: { basis: "exact-content-digest", confidence: "exact" },
@@ -136,16 +136,21 @@ const semanticKey = (node) => {
     return value === null ? null : `semantic\0${node.kind}\0${value}`;
 };
 const semanticValue = (node, properties) => {
-    if (node.kind === "endpoint")
-        return joined(properties.endpoint_kind, properties.value);
+    if (node.kind === "endpoint") {
+        const kind = nonEmptyString(properties.endpoint_kind);
+        const value = exactString(properties.value);
+        return kind === null || value === null ? null : `${kind}\0${value}`;
+    }
     if (node.kind === "storage")
         return joined(properties.storage_kind, properties.name ?? properties.mechanism);
     if (node.kind === "ipc-channel")
         return properties.resolution === "dynamic"
             ? null
-            : (stringValue(properties.channel) ?? firstLabel(node));
+            : (exactString(properties.channel) ?? firstLabel(node));
     if (node.kind === "context-bridge-api")
-        return firstLabel(node) ?? stringValue(properties.api_name);
+        return (firstLabel(node) ??
+            exactString(properties.api_key) ??
+            nonEmptyString(properties.api_name));
     if (node.kind === "native-export")
         return (joined(properties.specifier, stringList(properties.requested_members).join(",")) ?? firstLabel(node));
     if ([
@@ -156,8 +161,8 @@ const semanticValue = (node, properties) => {
     ].includes(node.kind))
         return joined(properties.declared_path, properties.resolved_path);
     if (node.kind === "package")
-        return stringValue(properties.name);
-    return canonicalPath(node) ?? stringValue(properties.path);
+        return nonEmptyString(properties.name);
+    return canonicalPath(node) ?? nonEmptyString(properties.path);
 };
 const canonicalPath = (node) => node.identity.strategy === "canonical-path" ? node.identity.path : null;
 const firstProperties = (node) => node.observations[0]?.properties ?? {};
@@ -171,10 +176,12 @@ const uniqueStringProperty = (node, name) => {
     return values.length === 1 ? (values[0] ?? null) : null;
 };
 const joined = (...values) => {
-    const strings = values.map(stringValue);
+    const strings = values.map(nonEmptyString);
     return strings.some((value) => value === null) ? null : strings.join("\0");
 };
-const stringValue = (value) => typeof value === "string" && value !== "" ? value : null;
+const nonEmptyString = (value) => typeof value === "string" && value !== "" ? value : null;
+/** A literal value such as `ipcMain.handle("")` keeps its exact empty text. */
+const exactString = (value) => typeof value === "string" ? value : null;
 const stringList = (value) => Array.isArray(value)
     ? value
         .filter((item) => typeof item === "string")

package/dist/domain/javascript/javascriptArtifactFiles.js

@@ -0,0 +1 @@
+export {};

package/dist/domain/{javascriptAstFingerprint.js → javascript/javascriptAstFingerprint.js}

@@ -1,25 +1,31 @@
 import { createHash } from "node:crypto";
 import * as t from "@babel/types";
-import { compareCodePoints } from "./canonicalOrdering.js";
+import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 import { propertyName } from "./javascriptAstValues.js";
+import { stringValue } from "./javascriptStaticAnalysisHelpers.js";
 /** Derive a rename-resistant syntax fingerprint without code execution. */
 export const fingerprintJavaScriptAst = (node) => {
     const tokens = [];
-    t.traverseFast(node, (current) => {
-        tokens.push(...semanticTokens(current));
-        return undefined;
+    traverseJavaScriptAst(node, {
+        enter: (current) => {
+            tokens.push(...semanticTokens(current));
+            return undefined;
+        },
     });
     return createHash("sha256").update(JSON.stringify(tokens)).digest("hex");
 };
 /** Collect statically declared CommonJS/bundler export names from one factory. */
 export const collectJavaScriptExports = (node) => {
     const exports = new Set();
-    t.traverseFast(node, (current) => {
-        if (t.isAssignmentExpression(current))
-            collectAssignmentExports(current.left, current.right, exports);
-        if (t.isCallExpression(current))
-            collectCallExports(current, exports);
-        return undefined;
+    traverseJavaScriptAst(node, {
+        enter: (current) => {
+            if (t.isAssignmentExpression(current))
+                collectAssignmentExports(current.left, current.right, exports);
+            if (t.isCallExpression(current))
+                collectCallExports(current, exports);
+            return undefined;
+        },
     });
     return {
         values: [...exports].sort(compareCodePoints),
@@ -94,17 +100,27 @@ const addExport = (output, name) => {
     output.add(name);
 };
 const memberPath = (node) => {
-    if (node === undefined || node === null)
-        return "";
-    if (t.isIdentifier(node) || t.isPrivateName(node))
-        return t.isIdentifier(node) ? node.name : "";
-    if (t.isThisExpression(node))
-        return "this";
-    if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
-        const object = t.isNode(node.object) ? memberPath(node.object) : "";
-        const property = propertyName(node.property);
-        return object === "" ? property : `${object}.${property}`;
+    const properties = [];
+    let current = node;
+    while (current !== undefined &&
+        current !== null &&
+        (t.isMemberExpression(current) || t.isOptionalMemberExpression(current))) {
+        properties.push(propertyName(current.property));
+        current = t.isNode(current.object) ? current.object : undefined;
+    }
+    const root = current !== undefined && t.isIdentifier(current)
+        ? current.name
+        : current !== undefined && t.isThisExpression(current)
+            ? "this"
+            : "";
+    if (properties.length === 0)
+        return root;
+    properties.reverse();
+    const path = root === "" ? [] : [root];
+    for (const property of properties) {
+        if (path.length === 0 && property === "")
+            continue;
+        path.push(property);
     }
-    return "";
+    return path.join(".");
 };
-const stringValue = (node) => t.isStringLiteral(node) ? node.value : undefined;

package/dist/domain/javascript/javascriptAstValues.js

@@ -0,0 +1,23 @@
+import * as t from "@babel/types";
+/** Read an identifier or literal property name without evaluating syntax. */
+export const propertyName = (node) => {
+    if (t.isIdentifier(node))
+        return node.name;
+    if (t.isStringLiteral(node) || t.isNumericLiteral(node))
+        return String(node.value);
+    return "";
+};
+/** Read a property name only when its syntax commits to one exact key. */
+export const semanticStaticPropertyName = (property, computed) => semanticStaticPropertyKey(property, computed) ?? "";
+/** Read an exact property key, preserving the legal empty-string key. */
+export const semanticStaticPropertyKey = (property, computed) => {
+    if (t.isStringLiteral(property) || t.isNumericLiteral(property))
+        return String(property.value);
+    return !computed && t.isIdentifier(property) ? property.name : null;
+};
+/**
+ * Display an exact JavaScript string as nonempty label text. Graph labels and
+ * artifact-local keys are nonempty, so the legal empty value is shown as `""`;
+ * producers keep the exact value in their properties.
+ */
+export const javascriptDisplayText = (value) => value === "" ? '""' : value;

package/dist/domain/{javascriptExportShapeComparison.js → javascript/javascriptExportShapeComparison.js}

@@ -1,4 +1,4 @@
-import { uniqueSorted } from "./canonicalOrdering.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
 import { digestExportShapeValue } from "./javascriptExportShapeComparisonIdentity.js";
 import { javaScriptExportShapeComparisonResultSchema, } from "./javascriptExportShapeComparisonSchemas.js";
 import { retainJavaScriptExportShapes, selectJavaScriptExport, } from "./javascriptExportShapeSelection.js";

package/dist/domain/{javascriptExportShapeComparisonSchemas.js → javascript/javascriptExportShapeComparisonSchemas.js}

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { evidenceSchema } from "./evidence.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { evidenceSchema } from "../evidence.js";
+import { prefixedDigestSchema } from "../digests.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
 const graphIdSchema = prefixedDigestSchema("jag");
 const nodeIdSchema = prefixedDigestSchema("jag_node");

package/dist/domain/{javascriptExportShapeSelection.js → javascript/javascriptExportShapeSelection.js}

@@ -1,5 +1,5 @@
 import { projectedExportReturnShapesSchema, } from "./javascriptExportShapeComparisonSchemas.js";
-import { compareCodePoints } from "./canonicalOrdering.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 /** Select one exact trusted export and its exact static return-shape observation. */
 export const selectJavaScriptExport = (side) => {
     const candidates = exportCandidates(side.graph);

package/dist/domain/{javascriptExportShapeVariants.js → javascript/javascriptExportShapeVariants.js}

@@ -1,5 +1,5 @@
 import { canonicalExportShapeValue, digestExportShapeValue, } from "./javascriptExportShapeComparisonIdentity.js";
-import { compareCodePoints, uniqueSorted } from "./canonicalOrdering.js";
+import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
 /** Pair variants only through reciprocal unique exact literal discriminants. */
 export const pairJavaScriptExportShapeVariants = (left, right) => {
     const leftKeys = discriminantOccurrences(left);

package/dist/domain/{javascriptFeatureSeed.js → javascript/javascriptFeatureSeed.js}

@@ -1,4 +1,5 @@
-import { compareCodePoints } from "./canonicalOrdering.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
+import { featureSeedMatchMode, } from "./javascriptFeatureTraceSchemas.js";
 /** Locate every graph node matching a typed literal seed without regex execution. */
 export const findApplicationFeatureSeeds = (nodes, seed) => nodes
     .flatMap((node) => seedMatch(node, seed))
@@ -17,7 +18,7 @@ const seedMatch = (node, seed) => {
             : [];
     if (!kindMatches(node, seed.kind))
         return [];
-    const mode = seed.match ?? (seed.kind === "string" ? "contains" : "exact");
+    const mode = featureSeedMatchMode(seed);
     const query = normalized(seed.value, seed.case_sensitive);
     const match = candidateFields(node, seed.kind).find((candidate) => {
         const value = normalized(candidate.value, seed.case_sensitive);
@@ -80,7 +81,7 @@ const memberFieldSuffixes = new Set([
 ]);
 const relevantFields = {
     route: [".label", ".value", ".path"],
-    api: [".label", ".api_name", ".key", ".methods", ".members"],
+    api: [".label", ".api_name", ".api_key", ".key", ".methods", ".members"],
     channel: [".label", ".channel", ".key"],
     module: [
         ".label",

package/dist/domain/{javascriptFeatureTrace.js → javascript/javascriptFeatureTrace.js}

@@ -1,5 +1,5 @@
-import { canonicalDigest } from "./comparisonSemantics.js";
-import { compareCodePoints, uniqueSorted } from "./canonicalOrdering.js";
+import { canonicalDigest } from "../comparisonSemantics.js";
+import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
 import { createJavaScriptApplicationGraph, } from "./javascriptApplicationGraph.js";
 import { applicationFeatureTraceResultSchema, } from "./javascriptFeatureTraceSchemas.js";
 import { findApplicationFeatureSeeds, } from "./javascriptFeatureSeed.js";

package/dist/domain/{javascriptFeatureTraceSchemas.js → javascript/javascriptFeatureTraceSchemas.js}

@@ -1,27 +1,41 @@
 import { z } from "zod";
-import { evidenceSchema, providerSchema } from "./evidence.js";
+import { evidenceSchema, providerSchema } from "../evidence.js";
 import { javascriptApplicationGraphSchema } from "./javascriptApplicationGraph.js";
-import { digestSchema } from "./../domain/digests.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { digestSchema } from "../digests.js";
+import { prefixedDigestSchema } from "../digests.js";
 const evidenceIdSchema = prefixedDigestSchema("ev");
 const nodeIdSchema = prefixedDigestSchema("jag_node");
 const edgeIdSchema = prefixedDigestSchema("jag_edge");
 const boundedTextSchema = z.string().min(1);
-/** Literal starting point for one application feature trace. */
-const applicationFeatureSeedSchema = z.strictObject({
-    kind: z.enum([
-        "node-id",
-        "route",
-        "string",
-        "api",
-        "channel",
-        "module",
-        "native-export",
-    ]),
-    value: boundedTextSchema,
-    match: z.enum(["exact", "contains"]).nullable().default(null),
-    case_sensitive: z.boolean().default(false),
-});
+/** Matching mode for a literal seed: string seeds default to containment. */
+export const featureSeedMatchMode = (seed) => seed.match ?? (seed.kind === "string" ? "contains" : "exact");
+const literalSeedKinds = [
+    "route",
+    "string",
+    "api",
+    "channel",
+    "module",
+    "native-export",
+];
+/**
+ * Literal starting point for one application feature trace. An empty value,
+ * such as the channel in `ipcMain.handle("")`, must be an explicit exact
+ * literal seed: empty containment would select every node.
+ */
+const applicationFeatureSeedSchema = z.union([
+    z.strictObject({
+        kind: z.enum(["node-id", ...literalSeedKinds]),
+        value: boundedTextSchema,
+        match: z.enum(["exact", "contains"]).nullable().default(null),
+        case_sensitive: z.boolean().default(false),
+    }),
+    z.strictObject({
+        kind: z.enum(literalSeedKinds),
+        value: z.literal(""),
+        match: z.literal("exact"),
+        case_sensitive: z.boolean().default(false),
+    }),
+]);
 /** Evidence-backed application graph and feature seed. */
 export const traceApplicationFeatureInputSchema = z
     .strictObject({

package/dist/domain/{javascriptFeatureTraversal.js → javascript/javascriptFeatureTraversal.js}

@@ -1,5 +1,5 @@
 import {} from "./javascriptApplicationGraph.js";
-import { compareCodePoints } from "./canonicalOrdering.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 /** Traverse a JAG without treating edge inference as observed reachability. */
 export const traverseApplicationFeature = (graph, seedNodeIds, direction) => {
     const nodeById = new Map(graph.nodes.map((node) => [node.node_id, node]));
@@ -54,5 +54,9 @@ const buildAdjacency = (edges, direction) => {
     return adjacency;
 };
 const addAdjacency = (adjacency, nodeId, entry) => {
-    adjacency.set(nodeId, [...(adjacency.get(nodeId) ?? []), entry]);
+    const entries = adjacency.get(nodeId);
+    if (entries === undefined)
+        adjacency.set(nodeId, [entry]);
+    else
+        entries.push(entry);
 };

package/dist/domain/{javascriptNativeHandoff.js → javascript/javascriptNativeHandoff.js}

@@ -1,4 +1,4 @@
-import { compareCodePoints } from "./canonicalOrdering.js";
+import { compareCodePoints } from "../canonicalOrdering.js";
 import {} from "./javascriptApplicationGraph.js";
 /** Build provider-neutral addon targets and link exact-subject native Evidence. */
 export const buildJavaScriptNativeHandoffs = (nodes, edges, nativeEvidence) => {