rea-agents 2.0.0 → 2.2.0

package/dist/domain/functionComparison.js

@@ -1,17 +1,9 @@
-import { diffLines } from "diff";
-import { parseFunctionEvidence, } from "./functionDossierEvidence.js";
-import { commentProjection, combineCoverage, functionMatch, identityProjection, isAutoName, normalizeCfg, project, referenceKindProjection, referenceProjection, sorted, stringAndNameProjection, } from "./functionComparisonNormalization.js";
+import { parseFunctionEvidence } from "./functionDossierEvidence.js";
+import { functionMatch } from "./functionComparisonNormalization.js";
 import { functionComparisonResultSchema, } from "./functionComparisonSchemas.js";
-import { canonicalJson, dimensionResult, overallStatus, summarize, unresolvedDimension as buildUnresolvedDimension, } from "./functionComparisonResults.js";
+import { overallStatus, summarize, canonicalJson, } from "./functionComparisonResults.js";
+import { compareDimensions } from "./functionComparisonDimensions.js";
 export { functionComparisonInputSchema, functionComparisonResultSchema, } from "./functionComparisonSchemas.js";
-const unresolvedDimension = (...[dimension, status, links, leftCount, rightCount, limitations]) => buildUnresolvedDimension({
-    dimension,
-    status,
-    links,
-    leftCount,
-    rightCount,
-    limitations,
-});
 /** Compare two explicit function Evidence page sets without fuzzy matching. */
 export const compareFunctions = (leftInput, rightInput, offset, limit) => {
     const left = parseFunctionEvidence(leftInput);
@@ -52,156 +44,3 @@ export const compareFunctions = (leftInput, rightInput, offset, limit) => {
         ].sort((a, b) => a.localeCompare(b)),
     });
 };
-const compareDimensions = (left, right, links, providersDiffer) => [
-    compareIdentity(left, right, links, providersDiffer),
-    compareText("pseudocode", left.pseudocode.text, right.pseudocode.text, left.pseudocode.complete, right.pseudocode.complete, links, providersDiffer),
-    compareText("assembly", left.collections.assembly.items.join("\n"), right.collections.assembly.items.join("\n"), left.collections.assembly.complete, right.collections.assembly.complete, links, providersDiffer, left.collections.assembly.truncated || right.collections.assembly.truncated, "Assembly is opaque provider text; relocation normalization is unavailable."),
-    compareComments(left, right, links, providersDiffer),
-    compareCalls(left, right, links, providersDiffer),
-    compareReferences(left, right, links, providersDiffer),
-    compareStringsAndNames(left, right, links, providersDiffer),
-    compareCfg(left, right, links, providersDiffer),
-];
-const compareText = (...[dimension, left, right, leftComplete, rightComplete, links, providersDiffer, explicitTruncation, limitation,]) => {
-    const truncated = explicitTruncation ?? (!leftComplete || !rightComplete);
-    if (!leftComplete || !rightComplete || providersDiffer)
-        return unresolvedDimension(dimension, truncated ? "truncated" : "unknown", links, left.length, right.length, [
-            ...(limitation === undefined ? [] : [limitation]),
-            ...(providersDiffer
-                ? ["Exact text comparison requires one provider identity."]
-                : []),
-        ]);
-    const changes = diffLines(left, right, {
-        timeout: 100,
-        maxEditLength: 10_000,
-    });
-    if (changes === undefined)
-        return unresolvedDimension(dimension, "unknown", links, left.length, right.length, ["Bounded line diff exceeded its time or edit-distance limit."]);
-    const delta = changes.reduce((summary, change) => ({
-        added_lines: summary.added_lines + (change.added ? (change.count ?? 0) : 0),
-        removed_lines: summary.removed_lines + (change.removed ? (change.count ?? 0) : 0),
-        hunks: summary.hunks + (change.added || change.removed ? 1 : 0),
-    }), { added_lines: 0, removed_lines: 0, hunks: 0 });
-    return dimensionResult({
-        dimension,
-        status: delta.hunks === 0 ? "unchanged" : "changed",
-        left,
-        right,
-        links,
-        providersDiffer,
-        leftCount: [...left].length,
-        rightCount: [...right].length,
-        textDelta: delta,
-        limitations: limitation === undefined ? [] : [limitation],
-    });
-};
-const compareCollections = (...[dimension, left, right, leftCoverage, rightCoverage, links, providersDiffer,]) => {
-    if (!leftCoverage.complete || !rightCoverage.complete)
-        return unresolvedDimension(dimension, leftCoverage.truncated || rightCoverage.truncated
-            ? "truncated"
-            : "unknown", links, left.length, right.length, []);
-    return compareValues(dimension, sorted(left), sorted(right), links, true, true, providersDiffer);
-};
-const compareComments = (left, right, links, providersDiffer) => {
-    const leftValues = commentProjection(left);
-    const rightValues = commentProjection(right);
-    if (leftValues === null || rightValues === null)
-        return unresolvedDimension("comments", "unknown", links, left.collections.comments.items.length, right.collections.comments.items.length, ["Comment locations could not be normalized relative to the function."]);
-    return compareCollections("comments", leftValues, rightValues, left.collections.comments, right.collections.comments, links, providersDiffer);
-};
-const compareStringsAndNames = (left, right, links, providersDiffer) => {
-    const leftValues = stringAndNameProjection(left);
-    const rightValues = stringAndNameProjection(right);
-    if (leftValues === null || rightValues === null)
-        return unresolvedDimension("strings_names", "unknown", links, null, null, [
-            "Reference source locations could not be normalized to function offsets.",
-        ]);
-    return compareCollections("strings_names", leftValues, rightValues, combineCoverage(left.collections.referenced_strings, left.collections.referenced_names), combineCoverage(right.collections.referenced_strings, right.collections.referenced_names), links, providersDiffer);
-};
-const compareReferences = (left, right, links, providersDiffer) => {
-    const leftCoverage = combineCoverage(left.collections.incoming_references, left.collections.outgoing_references);
-    const rightCoverage = combineCoverage(right.collections.incoming_references, right.collections.outgoing_references);
-    if (!leftCoverage.complete || !rightCoverage.complete)
-        return unresolvedDimension("references", leftCoverage.truncated || rightCoverage.truncated
-            ? "truncated"
-            : "unknown", links, leftCoverage.items.length, rightCoverage.items.length, []);
-    const leftProjection = referenceProjection(left);
-    const rightProjection = referenceProjection(right);
-    if (leftProjection.length === 0 && rightProjection.length === 0)
-        return compareValues("references", leftProjection, rightProjection, links, true, true, providersDiffer);
-    if (canonicalJson(leftProjection) !== canonicalJson(rightProjection))
-        return dimensionResult({
-            dimension: "references",
-            status: "changed",
-            left: leftProjection,
-            right: rightProjection,
-            links,
-            providersDiffer,
-            leftCount: leftProjection.length,
-            rightCount: rightProjection.length,
-            textDelta: null,
-            limitations: [
-                "Reference endpoints differ independently of provider reference-kind metadata.",
-            ],
-        });
-    const leftKinds = referenceKindProjection(left);
-    const rightKinds = referenceKindProjection(right);
-    if (leftKinds !== null && rightKinds !== null)
-        return compareValues("references", leftKinds, rightKinds, links, true, true, providersDiffer);
-    return unresolvedDimension("references", "unknown", links, leftProjection.length, rightProjection.length, [
-        "At least one provider did not expose reference kinds, so equal endpoints do not prove equal edge semantics.",
-    ]);
-};
-const compareIdentity = (left, right, links, providersDiffer) => {
-    if (isAutoName(left.procedure.name) || isAutoName(right.procedure.name))
-        return unresolvedDimension("identity", "unknown", links, null, null, [
-            "Address-derived function names are not stable cross-version identity.",
-        ]);
-    return compareValues("identity", identityProjection(left), identityProjection(right), links, true, true, providersDiffer);
-};
-const compareCalls = (left, right, links, providersDiffer) => {
-    const leftValues = callProjection(left);
-    const rightValues = callProjection(right);
-    if ([...leftValues, ...rightValues].some(({ name }) => isAutoName(name)))
-        return unresolvedDimension("calls", "unknown", links, leftValues.length, rightValues.length, ["Address-derived callee or caller names cannot be matched safely."]);
-    return compareCollections("calls", leftValues, rightValues, combineCoverage(left.collections.callers, left.collections.callees), combineCoverage(right.collections.callers, right.collections.callees), links, providersDiffer);
-};
-const callProjection = (snapshot) => [
-    ...project(snapshot.collections.callers, ({ name }) => ({
-        direction: "in",
-        name,
-    })),
-    ...project(snapshot.collections.callees, ({ name }) => ({
-        direction: "out",
-        name,
-    })),
-];
-const compareCfg = (left, right, links, providersDiffer) => {
-    const leftBlocks = left.collections.basic_blocks;
-    const rightBlocks = right.collections.basic_blocks;
-    if (!leftBlocks.complete || !rightBlocks.complete)
-        return unresolvedDimension("cfg", leftBlocks.truncated || rightBlocks.truncated ? "truncated" : "unknown", links, leftBlocks.items.length, rightBlocks.items.length, []);
-    const leftGraph = normalizeCfg(leftBlocks.items);
-    const rightGraph = normalizeCfg(rightBlocks.items);
-    if (leftGraph === null || rightGraph === null)
-        return unresolvedDimension("cfg", "unknown", links, leftBlocks.items.length, rightBlocks.items.length, ["CFG addresses could not be normalized to local block indices."]);
-    return compareValues("cfg", leftGraph, rightGraph, links, true, true, providersDiffer);
-};
-const compareValues = (...[dimension, left, right, links, leftComplete, rightComplete, providersDiffer,]) => {
-    if (!leftComplete || !rightComplete)
-        return unresolvedDimension(dimension, "unknown", links, null, null, []);
-    const leftJson = canonicalJson(left);
-    const rightJson = canonicalJson(right);
-    return dimensionResult({
-        dimension,
-        status: leftJson === rightJson ? "unchanged" : "changed",
-        left,
-        right,
-        links,
-        providersDiffer,
-        leftCount: Array.isArray(left) ? left.length : null,
-        rightCount: Array.isArray(right) ? right.length : null,
-        textDelta: null,
-        limitations: [],
-    });
-};

package/dist/domain/functionComparisonDimensions.js

@@ -0,0 +1,164 @@
+import { diffLines } from "diff";
+import { commentProjection, combineCoverage, identityProjection, isAutoName, normalizeCfg, project, referenceKindProjection, referenceProjection, sorted, stringAndNameProjection, } from "./functionComparisonNormalization.js";
+import { canonicalJson, dimensionResult, unresolvedDimension as buildUnresolvedDimension, } from "./functionComparisonResults.js";
+const unresolvedDimension = (...[dimension, status, links, leftCount, rightCount, limitations]) => buildUnresolvedDimension({
+    dimension,
+    status,
+    links,
+    leftCount,
+    rightCount,
+    limitations,
+});
+export const compareDimensions = (left, right, links, providersDiffer) => [
+    compareIdentity(left, right, links, providersDiffer),
+    compareText("pseudocode", left.pseudocode.text, right.pseudocode.text, left.pseudocode.complete, right.pseudocode.complete, links, providersDiffer),
+    compareText("assembly", left.collections.assembly.items.join("\n"), right.collections.assembly.items.join("\n"), left.collections.assembly.complete, right.collections.assembly.complete, links, providersDiffer, left.collections.assembly.truncated || right.collections.assembly.truncated, "Assembly is opaque provider text; relocation normalization is unavailable."),
+    compareComments(left, right, links, providersDiffer),
+    compareCalls(left, right, links, providersDiffer),
+    compareReferences(left, right, links, providersDiffer),
+    compareStringsAndNames(left, right, links, providersDiffer),
+    compareCfg(left, right, links, providersDiffer),
+];
+const compareText = (...[dimension, left, right, leftComplete, rightComplete, links, providersDiffer, explicitTruncation, limitation,]) => {
+    const truncated = explicitTruncation ?? (!leftComplete || !rightComplete);
+    if (!leftComplete || !rightComplete || providersDiffer)
+        return unresolvedDimension(dimension, truncated ? "truncated" : "unknown", links, left.length, right.length, [
+            ...(limitation === undefined ? [] : [limitation]),
+            ...(providersDiffer
+                ? ["Exact text comparison requires one provider identity."]
+                : []),
+        ]);
+    const changes = diffLines(left, right, {
+        timeout: 100,
+        maxEditLength: 10_000,
+    });
+    if (changes === undefined)
+        return unresolvedDimension(dimension, "unknown", links, left.length, right.length, ["Bounded line diff exceeded its time or edit-distance limit."]);
+    const delta = changes.reduce((summary, change) => ({
+        added_lines: summary.added_lines + (change.added ? (change.count ?? 0) : 0),
+        removed_lines: summary.removed_lines + (change.removed ? (change.count ?? 0) : 0),
+        hunks: summary.hunks + (change.added || change.removed ? 1 : 0),
+    }), { added_lines: 0, removed_lines: 0, hunks: 0 });
+    return dimensionResult({
+        dimension,
+        status: delta.hunks === 0 ? "unchanged" : "changed",
+        left,
+        right,
+        links,
+        providersDiffer,
+        leftCount: [...left].length,
+        rightCount: [...right].length,
+        textDelta: delta,
+        limitations: limitation === undefined ? [] : [limitation],
+    });
+};
+const compareCollections = (...[dimension, left, right, leftCoverage, rightCoverage, links, providersDiffer,]) => {
+    if (!leftCoverage.complete || !rightCoverage.complete)
+        return unresolvedDimension(dimension, leftCoverage.truncated || rightCoverage.truncated
+            ? "truncated"
+            : "unknown", links, left.length, right.length, []);
+    return compareValues(dimension, sorted(left), sorted(right), links, true, true, providersDiffer);
+};
+const compareComments = (left, right, links, providersDiffer) => {
+    const leftValues = commentProjection(left);
+    const rightValues = commentProjection(right);
+    if (leftValues === null || rightValues === null)
+        return unresolvedDimension("comments", "unknown", links, left.collections.comments.items.length, right.collections.comments.items.length, ["Comment locations could not be normalized relative to the function."]);
+    return compareCollections("comments", leftValues, rightValues, left.collections.comments, right.collections.comments, links, providersDiffer);
+};
+const compareStringsAndNames = (left, right, links, providersDiffer) => {
+    const leftValues = stringAndNameProjection(left);
+    const rightValues = stringAndNameProjection(right);
+    if (leftValues === null || rightValues === null)
+        return unresolvedDimension("strings_names", "unknown", links, null, null, [
+            "Reference source locations could not be normalized to function offsets.",
+        ]);
+    return compareCollections("strings_names", leftValues, rightValues, combineCoverage(left.collections.referenced_strings, left.collections.referenced_names), combineCoverage(right.collections.referenced_strings, right.collections.referenced_names), links, providersDiffer);
+};
+const compareReferences = (left, right, links, providersDiffer) => {
+    const leftCoverage = combineCoverage(left.collections.incoming_references, left.collections.outgoing_references);
+    const rightCoverage = combineCoverage(right.collections.incoming_references, right.collections.outgoing_references);
+    if (!leftCoverage.complete || !rightCoverage.complete)
+        return unresolvedDimension("references", leftCoverage.truncated || rightCoverage.truncated
+            ? "truncated"
+            : "unknown", links, leftCoverage.items.length, rightCoverage.items.length, []);
+    const leftProjection = referenceProjection(left);
+    const rightProjection = referenceProjection(right);
+    if (leftProjection.length === 0 && rightProjection.length === 0)
+        return compareValues("references", leftProjection, rightProjection, links, true, true, providersDiffer);
+    if (canonicalJson(leftProjection) !== canonicalJson(rightProjection))
+        return dimensionResult({
+            dimension: "references",
+            status: "changed",
+            left: leftProjection,
+            right: rightProjection,
+            links,
+            providersDiffer,
+            leftCount: leftProjection.length,
+            rightCount: rightProjection.length,
+            textDelta: null,
+            limitations: [
+                "Reference endpoints differ independently of provider reference-kind metadata.",
+            ],
+        });
+    const leftKinds = referenceKindProjection(left);
+    const rightKinds = referenceKindProjection(right);
+    if (leftKinds !== null && rightKinds !== null)
+        return compareValues("references", leftKinds, rightKinds, links, true, true, providersDiffer);
+    return unresolvedDimension("references", "unknown", links, leftProjection.length, rightProjection.length, [
+        "At least one provider did not expose reference kinds, so equal endpoints do not prove equal edge semantics.",
+    ]);
+};
+const compareIdentity = (left, right, links, providersDiffer) => {
+    if (isAutoName(left.procedure.name) || isAutoName(right.procedure.name))
+        return unresolvedDimension("identity", "unknown", links, null, null, [
+            "Address-derived function names are not stable cross-version identity.",
+        ]);
+    return compareValues("identity", identityProjection(left), identityProjection(right), links, true, true, providersDiffer);
+};
+const compareCalls = (left, right, links, providersDiffer) => {
+    const leftValues = callProjection(left);
+    const rightValues = callProjection(right);
+    if ([...leftValues, ...rightValues].some(({ name }) => isAutoName(name)))
+        return unresolvedDimension("calls", "unknown", links, leftValues.length, rightValues.length, ["Address-derived callee or caller names cannot be matched safely."]);
+    return compareCollections("calls", leftValues, rightValues, combineCoverage(left.collections.callers, left.collections.callees), combineCoverage(right.collections.callers, right.collections.callees), links, providersDiffer);
+};
+const callProjection = (snapshot) => [
+    ...project(snapshot.collections.callers, ({ name }) => ({
+        direction: "in",
+        name,
+    })),
+    ...project(snapshot.collections.callees, ({ name }) => ({
+        direction: "out",
+        name,
+    })),
+];
+const compareCfg = (left, right, links, providersDiffer) => {
+    const leftBlocks = left.collections.basic_blocks;
+    const rightBlocks = right.collections.basic_blocks;
+    if (!leftBlocks.complete || !rightBlocks.complete)
+        return unresolvedDimension("cfg", leftBlocks.truncated || rightBlocks.truncated ? "truncated" : "unknown", links, leftBlocks.items.length, rightBlocks.items.length, []);
+    const leftGraph = normalizeCfg(leftBlocks.items);
+    const rightGraph = normalizeCfg(rightBlocks.items);
+    if (leftGraph === null || rightGraph === null)
+        return unresolvedDimension("cfg", "unknown", links, leftBlocks.items.length, rightBlocks.items.length, ["CFG addresses could not be normalized to local block indices."]);
+    return compareValues("cfg", leftGraph, rightGraph, links, true, true, providersDiffer);
+};
+const compareValues = (...[dimension, left, right, links, leftComplete, rightComplete, providersDiffer,]) => {
+    if (!leftComplete || !rightComplete)
+        return unresolvedDimension(dimension, "unknown", links, null, null, []);
+    const leftJson = canonicalJson(left);
+    const rightJson = canonicalJson(right);
+    return dimensionResult({
+        dimension,
+        status: leftJson === rightJson ? "unchanged" : "changed",
+        left,
+        right,
+        links,
+        providersDiffer,
+        leftCount: Array.isArray(left) ? left.length : null,
+        rightCount: Array.isArray(right) ? right.length : null,
+        textDelta: null,
+        limitations: [],
+    });
+};

package/dist/domain/javascriptApplicationVersionItems.js

@@ -145,20 +145,32 @@ const relationshipSignature = (node, side, context) => {
     const signatures = graph.edges.flatMap((edge) => {
         if (edge.source_node_id === node.node_id)
             return [
-                edgeSignature("out", edge.relation, edge.target_node_id, paired, nodeById),
+                edgeSignature({
+                    direction: "out",
+                    relation: edge.relation,
+                    neighborId: edge.target_node_id,
+                    paired,
+                    nodeById,
+                }),
             ];
         if (edge.target_node_id === node.node_id)
             return [
-                edgeSignature("in", edge.relation, edge.source_node_id, paired, nodeById),
+                edgeSignature({
+                    direction: "in",
+                    relation: edge.relation,
+                    neighborId: edge.source_node_id,
+                    paired,
+                    nodeById,
+                }),
             ];
         return [];
     });
     return canonical(signatures.sort(compareCodePoints));
 };
-const edgeSignature = (direction, relation, neighborId, paired, nodeById) => {
-    const mapped = paired.get(neighborId);
-    const neighbor = nodeById.get(neighborId);
-    return `${direction}\0${relation}\0${mapped ?? `unmatched:${neighbor?.kind ?? "unknown"}`}`;
+const edgeSignature = (context) => {
+    const mapped = context.paired.get(context.neighborId);
+    const neighbor = context.nodeById.get(context.neighborId);
+    return `${context.direction}\0${context.relation}\0${mapped ?? `unmatched:${neighbor?.kind ?? "unknown"}`}`;
 };
 const itemEvidenceLinks = (left, right, context) => [
     ...new Set([

package/dist/domain/javascriptApplicationVersionKeys.js

@@ -23,7 +23,7 @@ export const matchJavaScriptApplicationVersions = (leftNodes, rightNodes) => {
     const rightCandidates = new Map();
     const pairs = [];
     for (const tier of matchTiers())
-        applyTier(left, right, pairs, leftCandidates, rightCandidates, tier);
+        applyTier({ left, right, pairs, leftCandidates, rightCandidates, tier });
     const remainingLeft = sortedNodes(left.values());
     const remainingRight = sortedNodes(right.values());
     const leftIds = new Set(remainingLeft.map(({ node_id: id }) => id));
@@ -36,24 +36,24 @@ export const matchJavaScriptApplicationVersions = (leftNodes, rightNodes) => {
         candidatesForRight: filteredCandidates(rightCandidates, leftIds),
     };
 };
-const applyTier = (left, right, pairs, leftCandidates, rightCandidates, tier) => {
-    const leftByKey = nodesByKey(left.values(), tier.key);
-    const rightByKey = nodesByKey(right.values(), tier.key);
+const applyTier = (context) => {
+    const leftByKey = nodesByKey(context.left.values(), context.tier.key);
+    const rightByKey = nodesByKey(context.right.values(), context.tier.key);
     for (const key of [...leftByKey.keys()].sort(compareCodePoints)) {
         const leftGroup = leftByKey.get(key) ?? [];
         const rightGroup = rightByKey.get(key) ?? [];
         if (rightGroup.length === 0)
             continue;
-        recordCandidates(leftGroup, rightGroup, leftCandidates, rightCandidates);
+        recordCandidates(leftGroup, rightGroup, context.leftCandidates, context.rightCandidates);
         if (leftGroup.length !== 1 || rightGroup.length !== 1)
             continue;
         const leftNode = leftGroup[0];
         const rightNode = rightGroup[0];
         if (leftNode === undefined || rightNode === undefined)
             continue;
-        pairs.push({ left: leftNode, right: rightNode, ...tier });
-        left.delete(leftNode.node_id);
-        right.delete(rightNode.node_id);
+        context.pairs.push({ left: leftNode, right: rightNode, ...context.tier });
+        context.left.delete(leftNode.node_id);
+        context.right.delete(rightNode.node_id);
     }
 };
 const nodesByKey = (nodes, keyFor) => {

package/dist/domain/javascriptExportInstrumentation.js

@@ -0,0 +1,97 @@
+import { createHash } from "node:crypto";
+import { z } from "zod";
+const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
+export const javascriptExportInstrumentationInputSchema = z.strictObject({
+    artifact_path: z.string().min(1).max(4_096),
+    artifact_sha256: digestSchema,
+    selection: z.strictObject({
+        byte_start: z.number().int().min(0),
+        byte_end: z.number().int().min(1),
+        selected_sha256: digestSchema,
+        export_name: z.string().regex(/^[A-Za-z_$][A-Za-z0-9_$]{0,199}$/u),
+    }),
+});
+export const javascriptExportTransformationManifestSchema = z.strictObject({
+    schema_version: z.literal(1),
+    kind: z.literal("commonjs-factory-export-v1"),
+    artifact_path: z.string().min(1).max(4_096),
+    original_sha256: digestSchema,
+    original_byte_length: z.number().int().min(0),
+    instrumented_sha256: digestSchema,
+    instrumented_byte_length: z.number().int().min(0),
+    selected_range: z.strictObject({
+        byte_start: z.number().int().min(0),
+        byte_end: z.number().int().min(1),
+        selected_sha256: digestSchema,
+    }),
+    inserted_ranges: z
+        .array(z.strictObject({
+        byte_start: z.number().int().min(0),
+        byte_end: z.number().int().min(1),
+        inserted_sha256: digestSchema,
+        purpose: z.enum(["factory-prefix", "export-binding", "factory-suffix"]),
+    }))
+        .length(3),
+    output_format: z.literal("commonjs-factory"),
+    source_map: z.literal(null),
+});
+/** Instrument one exact UTF-8 expression range without mutating source bytes. */
+export const instrumentJavaScriptExport = (source, rawInput) => {
+    const input = javascriptExportInstrumentationInputSchema.parse(rawInput);
+    if (sha256(source) !== input.artifact_sha256)
+        throw new TypeError("JavaScript instrumentation artifact digest mismatch");
+    const { byte_start: start, byte_end: end } = input.selection;
+    if (end <= start || end > source.byteLength)
+        throw new TypeError("JavaScript instrumentation selection is out of bounds");
+    const selected = source.slice(start, end);
+    if (sha256(selected) !== input.selection.selected_sha256)
+        throw new TypeError("JavaScript instrumentation selection digest mismatch");
+    decodeUtf8(source);
+    decodeUtf8(selected);
+    const prefix = encode("function(module, exports, require) {\n");
+    const binding = encode(`\nmodule.exports[${JSON.stringify(input.selection.export_name)}] = (${decodeUtf8(selected)});\n`);
+    const suffix = encode("}\n");
+    const bytes = concatenate([prefix, source, binding, suffix]);
+    const bindingStart = prefix.byteLength + source.byteLength;
+    const suffixStart = bindingStart + binding.byteLength;
+    const manifest = javascriptExportTransformationManifestSchema.parse({
+        schema_version: 1,
+        kind: "commonjs-factory-export-v1",
+        artifact_path: input.artifact_path,
+        original_sha256: input.artifact_sha256,
+        original_byte_length: source.byteLength,
+        instrumented_sha256: sha256(bytes),
+        instrumented_byte_length: bytes.byteLength,
+        selected_range: {
+            byte_start: start,
+            byte_end: end,
+            selected_sha256: input.selection.selected_sha256,
+        },
+        inserted_ranges: [
+            range(0, prefix, "factory-prefix"),
+            range(bindingStart, binding, "export-binding"),
+            range(suffixStart, suffix, "factory-suffix"),
+        ],
+        output_format: "commonjs-factory",
+        source_map: null,
+    });
+    return { bytes, manifest };
+};
+const range = (start, bytes, purpose) => ({
+    byte_start: start,
+    byte_end: start + bytes.byteLength,
+    inserted_sha256: sha256(bytes),
+    purpose,
+});
+const encode = (value) => new TextEncoder().encode(value);
+const decodeUtf8 = (value) => new TextDecoder("utf-8", { fatal: true }).decode(value);
+const concatenate = (values) => {
+    const output = new Uint8Array(values.reduce((total, value) => total + value.byteLength, 0));
+    let offset = 0;
+    for (const value of values) {
+        output.set(value, offset);
+        offset += value.byteLength;
+    }
+    return output;
+};
+const sha256 = (value) => createHash("sha256").update(value).digest("hex");

package/dist/domain/javascriptFeatureTraversal.js

@@ -18,11 +18,23 @@ export const traverseApplicationFeature = (graph, seedNodeIds, direction, limits
         const depth = depths.get(current) ?? 0;
         for (const entry of adjacency.get(current) ?? []) {
             if (depth >= limits.max_depth) {
-                recordOmission(entry, current, omittedNodes, omittedEdges, frontier);
+                recordOmission({
+                    entry,
+                    current,
+                    omittedNodes,
+                    omittedEdges,
+                    frontier,
+                });
                 continue;
             }
             if (!visited.has(entry.nextNodeId) && visited.size >= limits.max_nodes) {
-                recordOmission(entry, current, omittedNodes, omittedEdges, frontier);
+                recordOmission({
+                    entry,
+                    current,
+                    omittedNodes,
+                    omittedEdges,
+                    frontier,
+                });
                 continue;
             }
             if (!retainedEdges.has(entry.edge.edge_id) &&
@@ -80,9 +92,9 @@ const buildAdjacency = (edges, direction) => {
 const addAdjacency = (adjacency, nodeId, entry) => {
     adjacency.set(nodeId, [...(adjacency.get(nodeId) ?? []), entry]);
 };
-const recordOmission = (entry, current, omittedNodes, omittedEdges, frontier) => {
-    omittedNodes.add(entry.nextNodeId);
-    omittedEdges.add(entry.edge.edge_id);
-    frontier.add(current);
-    frontier.add(entry.nextNodeId);
+const recordOmission = (context) => {
+    context.omittedNodes.add(context.entry.nextNodeId);
+    context.omittedEdges.add(context.entry.edge.edge_id);
+    context.frontier.add(context.current);
+    context.frontier.add(context.entry.nextNodeId);
 };

package/dist/domain/javascriptRuntimeStaticCandidates.js

@@ -61,7 +61,8 @@ const candidatesForLayer = (layer) => {
 const candidateCategory = (node) => {
     if (node.kind === "electron-renderer")
         return "renderer";
-    if (node.kind === "javascript-asset" || node.kind === "javascript-module")
+    if (node.kind === "javascript-asset" ||
+        (node.kind === "javascript-module" && !isStaticSourceModule(node)))
         return "javascript";
     if (node.kind === "worker")
         return "worker";
@@ -69,6 +70,7 @@ const candidateCategory = (node) => {
         return "service-worker";
     return null;
 };
+const isStaticSourceModule = (node) => node.observations.some(({ properties }) => properties.semantic_role === "source-module");
 const indexStaticPaths = (graph) => {
     const nodes = new Map(graph.nodes.map((candidate) => [candidate.node_id, candidate]));
     const relatedBySource = new Map();