rea-agents 4.1.0 → 6.0.0

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,8 +1,8 @@
-import { uniqueSorted } from "./canonicalOrdering.js";
-import { digestExportShapeValue } from "./javascriptExportShapeComparisonIdentity.js";
+import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
+import { canonicalExportShapeValue, digestExportShapeValue, } from "./javascriptExportShapeComparisonIdentity.js";
 import { javaScriptExportShapeComparisonResultSchema, } from "./javascriptExportShapeComparisonSchemas.js";
 import { retainJavaScriptExportShapes, selectJavaScriptExport, } from "./javascriptExportShapeSelection.js";
-import { buildJavaScriptExportShapeChanges, compareJavaScriptExportShapeChanges, hasPartialJavaScriptExportPropertyCoverage, pairJavaScriptExportShapeVariants, } from "./javascriptExportShapeVariants.js";
+import { buildJavaScriptExportShapeChanges, hasPartialJavaScriptExportPropertyCoverage, pairJavaScriptExportShapeVariants, } from "./javascriptExportShapeVariants.js";
 /** Compare exact selected export return shapes without executing JavaScript. */
 export const compareJavaScriptExportShapes = (input) => {
     const left = selectJavaScriptExport(input.left);
@@ -11,14 +11,14 @@ export const compareJavaScriptExportShapes = (input) => {
     const rightRetained = retainJavaScriptExportShapes(right);
     const pairing = pairJavaScriptExportShapeVariants(leftRetained.shapes, rightRetained.shapes);
     const evidenceLinks = evidencePair(input.left.evidenceId, input.right.evidenceId);
-    const allChanges = buildJavaScriptExportShapeChanges({
+    const allChanges = sortChanges(buildJavaScriptExportShapeChanges({
         leftSelection: left,
         rightSelection: right,
         pairing,
         leftShapes: leftRetained.shapes,
         rightShapes: rightRetained.shapes,
         evidenceLinks,
-    }).sort(compareJavaScriptExportShapeChanges);
+    }));
     const changes = allChanges;
     const omittedChanges = 0;
     const coverage = comparisonCoverage({
@@ -46,6 +46,22 @@ export const compareJavaScriptExportShapes = (input) => {
         comparison_id: `jesc_${digestExportShapeValue(semantic)}`,
     });
 };
+const sortChanges = (changes) => changes
+    .map((change, index) => ({
+    change,
+    index,
+    sortKey: canonicalExportShapeValue({
+        discriminant: change.discriminant,
+        path: change.path,
+        status: change.status,
+        left_source_range: change.left_source_range,
+        right_source_range: change.right_source_range,
+        change_id: change.change_id,
+    }),
+}))
+    .sort((left, right) => compareCodePoints(left.sortKey, right.sortKey) ||
+    left.index - right.index)
+    .map(({ change }) => change);
 const comparisonCoverage = (context) => {
     const leftSource = context.left.projection?.return_shape_coverage;
     const rightSource = context.right.projection?.return_shape_coverage;

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);
@@ -61,8 +61,6 @@ export const buildJavaScriptExportShapeChanges = (input) => {
     });
     return [...paired, ...unpairedLeft, ...unpairedRight];
 };
-/** Sort changes by semantic content rather than traversal order. */
-export const compareJavaScriptExportShapeChanges = (left, right) => compareCodePoints(canonicalExportShapeValue(changeSortKey(left)), canonicalExportShapeValue(changeSortKey(right)));
 /** Report whether any retained shape lacks complete property coverage. */
 export const hasPartialJavaScriptExportPropertyCoverage = (shapes) => shapes.some((shape) => shape.property_coverage.some(({ status }) => status === "partial"));
 const discriminantOccurrences = (shapes) => {
@@ -270,14 +268,6 @@ const changeWithId = (semantic) => ({
     ...semantic,
     change_id: `jesc_change_${digestExportShapeValue(semantic)}`,
 });
-const changeSortKey = (change) => ({
-    discriminant: change.discriminant,
-    path: change.path,
-    status: change.status,
-    left_source_range: change.left_source_range,
-    right_source_range: change.right_source_range,
-    change_id: change.change_id,
-});
 const literalValue = (field) => field.state === "literal" && isPrimitive(field.value)
     ? { found: true, value: field.value }
     : { found: false };

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) => {

package/dist/domain/javascript/javascriptRecovery.js

@@ -0,0 +1,88 @@
+import { z } from "zod";
+import { digestSchema } from "../digests.js";
+import { analyzeJavaScriptApplicationInputSchema } from "./javascriptApplicationAnalysis.js";
+/** Recover derived readable modules from one explicitly selected local script. */
+export const javascriptRecoveryInputSchema = z.strictObject({
+    path: z
+        .string()
+        .min(1)
+        .describe("Absolute path to a UTF-8 JavaScript file; never executed"),
+    output_directory: z
+        .string()
+        .min(1)
+        .describe("Absolute absent output directory; parent must exist"),
+    extraction_mode: z
+        .enum(["structural", "heuristic", "inspection"])
+        .default("structural")
+        .describe("Structural module boundaries, heuristic fallback, or finer inspection-only regions"),
+    rewrite_level: z
+        .enum(["minimal", "standard", "aggressive"])
+        .default("standard")
+        .describe("Upstream syntax recovery level; runtime equivalence remains unverified"),
+});
+const fileSchema = z.strictObject({
+    path: z.string().min(1),
+    sha256: digestSchema,
+    bytes: z.number().int().nonnegative(),
+});
+const rangeSchema = z.strictObject({
+    start: z.number().int().nonnegative(),
+    end: z.number().int().nonnegative(),
+});
+/** Complete published artifacts and exact producer provenance for source recovery. */
+export const javascriptRecoveryResultSchema = z.strictObject({
+    source: fileSchema.extend({
+        snapshot_path: z.string().min(1),
+        published_copy: fileSchema,
+    }),
+    engine: z.strictObject({
+        id: z.string().min(1),
+        version: z.string().min(1),
+        executable: fileSchema,
+        audited_source_revision: z.string().min(1),
+        executed_source_revision: z.string().nullable(),
+    }),
+    options: z.strictObject({
+        extraction_mode: javascriptRecoveryInputSchema.shape.extraction_mode.removeDefault(),
+        rewrite_level: javascriptRecoveryInputSchema.shape.rewrite_level.removeDefault(),
+    }),
+    status: z.enum(["complete", "partial"]),
+    detected_formats: z.array(z.string()),
+    reported_safety: z.string(),
+    reported_strategy: z.string(),
+    reported_format: z.string(),
+    total: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+    modules: z.array(z.strictObject({
+        reported_filename: z.string().min(1),
+        reported_status: z.string().min(1),
+        artifact: fileSchema,
+        source_map: fileSchema.nullable(),
+        provenance: z.strictObject({
+            reported_input: z.string(),
+            original_path: z.string(),
+            original_sha256: digestSchema,
+            extraction: z.string(),
+            byte_ranges: z.array(rangeSchema),
+            context_byte_ranges: z.array(rangeSchema),
+            range_semantics: z.literal("half-open-utf8-bytes"),
+        }),
+    })),
+    warnings: z.array(z.strictObject({
+        filename: z.string(),
+        kind: z.string(),
+        is_error: z.boolean(),
+        message: z.string(),
+    })),
+    report: fileSchema,
+    provenance: fileSchema,
+    manifest: fileSchema,
+    analysis_input: z
+        .strictObject({
+        input_path: analyzeJavaScriptApplicationInputSchema.shape.input_path,
+        format: z.literal("directory"),
+    })
+        .nullable(),
+    runtime_equivalence: z.literal("unknown"),
+    limitations: z.array(z.string()),
+});

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

@@ -1,5 +1,5 @@
 import {} from "./javascriptApplicationGraph.js";
-import { uniqueSorted } from "./canonicalOrdering.js";
+import { uniqueSorted } from "../canonicalOrdering.js";
 import { createStaticRuntimeScope, mappedRuntimePaths, staticNodeWithinRuntimeScope, } from "./javascriptRuntimeStaticCandidates.js";
 /** Classify static code presence without claiming bundled module execution. */
 export const classifyStaticLoadStates = (layers, runtimeEntities, matches, options) => {

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

@@ -1,6 +1,6 @@
 import { z } from "zod";
-import { browserEndpointSchema } from "./browserObservation.js";
-import { prefixedDigestSchema } from "./../domain/digests.js";
+import { browserEndpointSchema } from "../browserObservation.js";
+import { prefixedDigestSchema } from "../digests.js";
 const observationTextSchema = z.string().min(1);
 const runtimeEndpoint = {
     inspector_endpoint: browserEndpointSchema,

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

@@ -1,8 +1,8 @@
 import { isAbsolute } from "node:path";
-import { canonicalDigest } from "./comparisonSemantics.js";
-import { isPathWithinRoot } from "./localPath.js";
+import { canonicalDigest } from "../comparisonSemantics.js";
+import { isPathWithinRoot } from "../localPath.js";
 import { z } from "zod";
-import { classifyBrowserCompleteness, } from "./browserCompleteness.js";
+import { classifyBrowserCompleteness, } from "../browserCompleteness.js";
 import { electronActiveObservationResultSchema, } from "./electronActiveObservation.js";
 /** Parse active Electron Evidence as a bounded, target-only runtime capture. */
 export const parseActiveElectronCapture = (evidence) => {

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

@@ -1,5 +1,5 @@
 import { createJavaScriptApplicationGraph, createJavaScriptApplicationNode, } from "./javascriptApplicationGraph.js";
-import { compareCodePoints, uniqueSorted } from "./canonicalOrdering.js";
+import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
 /** Merge source graphs, runtime nodes, and inferred mappings into one valid JAG. */
 export const buildReconciledApplicationGraph = (input) => {
     const merged = mergeNodes([