rea-agents 6.0.0 → 6.2.0

package/dist/domain/javascript/javascriptApplicationGraph.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { canonicalDigest, canonicalJson } from "../comparisonSemantics.js";
 import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
+import { freezeOwnedJsonSnapshotSteps } from "../immutableJson.js";
 import { applicationEdgeInputSchema, applicationEdgeSchema, applicationNodeInputSchema, applicationNodeObservationSchema, applicationNodeSchema, javascriptApplicationGraphInputSchema, javascriptApplicationGraphRecordSchema, } from "./javascriptApplicationGraphSchemas.js";
 const OBSERVATION_IDENTIFIER_STRATEGY = {
     strategy: "semantic-content-sha256",
@@ -62,6 +63,18 @@ const checkEvidenceNormalization = (evidence, path, context) => {
             path: [...path, "location"],
         });
 };
+const sourceMapObservationMatchesIdentity = (identity, observation) => {
+    const { evidence, source_map_reference: reference } = observation;
+    return (reference !== null &&
+        evidence.state === "observed" &&
+        evidence.artifact.available &&
+        evidence.artifact.sha256 === identity.source_map_sha256 &&
+        reference.source_name === identity.original_source &&
+        reference.source_root === identity.source_root &&
+        evidence.location.available &&
+        evidence.location.value.kind === "artifact-path" &&
+        reference.map_path === evidence.location.value.path);
+};
 const observationMatchesIdentity = (node, observation) => {
     const { identity } = node;
     const { evidence } = observation;
@@ -70,9 +83,7 @@ const observationMatchesIdentity = (node, observation) => {
             evidence.artifact.available &&
             evidence.artifact.sha256 === identity.sha256);
     if (identity.strategy === "source-map-original")
-        return (evidence.state === "observed" &&
-            evidence.artifact.available &&
-            evidence.artifact.sha256 === identity.source_map_sha256);
+        return sourceMapObservationMatchesIdentity(identity, observation);
     if (identity.strategy === "canonical-path")
         return (evidence.artifact.available &&
             evidence.artifact.sha256 === identity.artifact_sha256 &&
@@ -125,6 +136,19 @@ const checkNode = (node, index, context) => {
                     "observation_id",
                 ],
             });
+        if (node.identity.strategy === "source-map-original" &&
+            !observationMatchesIdentity(node, observation))
+            context.addIssue({
+                code: "custom",
+                message: "Source-map observation must retain its exact declaration and map location",
+                path: [
+                    "nodes",
+                    index,
+                    "observations",
+                    observationIndex,
+                    "source_map_reference",
+                ],
+            });
         checkEvidenceNormalization(observation.evidence, ["nodes", index, "observations", observationIndex, "evidence"], context);
     }
     if (!node.observations.some((observation) => observationMatchesIdentity(node, observation)))
@@ -255,6 +279,18 @@ export const createJavaScriptApplicationGraph = (input) => {
         graph_id: `jag_${canonicalDigest(semantic, "JavaScript Application Graph")}`,
     });
 };
+const validatedImmutableApplicationGraphs = new WeakSet();
+/** Clone and validate synchronously, then return steps to seal the owned graph. */
+export const createImmutableJavaScriptApplicationGraphSteps = (input) => sealValidatedApplicationGraphSteps(createJavaScriptApplicationGraph(input));
+function* sealValidatedApplicationGraphSteps(graph) {
+    yield* freezeOwnedJsonSnapshotSteps(graph);
+    validatedImmutableApplicationGraphs.add(graph);
+    return graph;
+}
+/** Recognize the exact completely sealed graph produced by the owned factory. */
+export const isValidatedImmutableJavaScriptApplicationGraph = (value) => typeof value === "object" &&
+    value !== null &&
+    validatedImmutableApplicationGraphs.has(value);
 /** Parse a stored graph and reject stale IDs. */
 export const parseJavaScriptApplicationGraph = (input) => javascriptApplicationGraphSchema.parse(input);
 /** Compute the byte-stable SHA-256 commitment of a verified graph. */

package/dist/domain/javascript/javascriptApplicationGraphSchemas.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { javascriptSourceMapReferenceSchema } from "./javascriptSourceMapPaths.js";
 import { applicationCoverageSchema, applicationGraphEvidenceSchema, applicationNodeIdentitySchema, } from "./javascriptApplicationEvidenceSchemas.js";
 import { jsonValueSchema } from "../jsonValue.js";
 import { prefixedDigestSchema } from "../digests.js";
@@ -61,13 +62,19 @@ export const JAVASCRIPT_APPLICATION_RELATIONS = [
 const applicationRelationSchema = z.enum(JAVASCRIPT_APPLICATION_RELATIONS);
 const applicationPropertiesSchema = z.record(z.string().min(1), jsonValueSchema);
 /** One node observation before its semantic identifier is derived. */
-const applicationNodeObservationInputSchema = z.strictObject({
+const applicationNodeObservationBaseSchema = z.strictObject({
     label: z.string().min(1).nullable(),
+    source_map_reference: javascriptSourceMapReferenceSchema.nullable(),
     properties: applicationPropertiesSchema,
     evidence: applicationGraphEvidenceSchema,
 });
+const applicationNodeObservationInputSchema = applicationNodeObservationBaseSchema.extend({
+    source_map_reference: javascriptSourceMapReferenceSchema
+        .nullable()
+        .default(null),
+});
 /** One immutable, evidence-bearing observation attached to an entity. */
-export const applicationNodeObservationSchema = applicationNodeObservationInputSchema.extend({
+export const applicationNodeObservationSchema = applicationNodeObservationBaseSchema.extend({
     observation_id: prefixedDigestSchema("jag_observation"),
     identifier_strategy: z.strictObject({
         strategy: z.literal("semantic-content-sha256"),

package/dist/domain/javascript/javascriptApplicationVersionItems.js

@@ -1,6 +1,5 @@
 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) => {
     const pairByLeft = new Map(matching.pairs.map(({ left, right }) => [
@@ -204,7 +203,11 @@ const locations = (node) => node.observations
     .map(({ evidence }) => evidence.location.available ? evidence.location.value : evidence.location)
     .sort((left, right) => compareCodePoints(canonicalJson(left), canonicalJson(right)));
 const properties = (node) => node.observations
-    .map(({ label, properties: values }) => ({ label, properties: values }))
+    .map(({ label, properties: values, source_map_reference }) => ({
+    label,
+    properties: values,
+    source_map_reference,
+}))
     .sort((left, right) => compareCodePoints(canonicalJson(left), canonicalJson(right)));
 const relationshipSignature = (node, side, context) => {
     const graph = side === "left" ? context.leftGraph : context.rightGraph;

package/dist/domain/javascript/javascriptApplicationVersionKeys.js

@@ -1,3 +1,4 @@
+import { canonicalJson } from "../comparisonSemantics.js";
 import { compareCodePoints } from "../canonicalOrdering.js";
 const matchTiers = () => [
     {
@@ -112,7 +113,7 @@ const moduleSourceDigestKey = (node) => {
 };
 const sourceMapKey = (node) => node.kind === "source-module" &&
     node.identity.strategy === "source-map-original"
-    ? `source-map\0${node.identity.original_source}`
+    ? `source-map\0${canonicalJson([node.identity.source_root, node.identity.original_source])}`
     : null;
 const structuralFingerprintKey = (node) => {
     if (node.kind !== "javascript-module")

package/dist/domain/javascript/javascriptAstValues.js

@@ -1,4 +1,24 @@
 import * as t from "@babel/types";
+/** Read one syntax-level primitive only when its value is exact. */
+export const readExactJavaScriptLiteral = (node) => {
+    if (t.isStringLiteral(node))
+        return { found: true, value: node.value };
+    if (t.isNumericLiteral(node) && Number.isFinite(node.value))
+        return { found: true, value: node.value };
+    if (t.isBooleanLiteral(node))
+        return { found: true, value: node.value };
+    if (t.isNullLiteral(node))
+        return { found: true, value: null };
+    if (t.isTemplateLiteral(node) &&
+        node.expressions.length === 0 &&
+        node.quasis.length === 1) {
+        const cooked = node.quasis[0]?.value.cooked;
+        return cooked === null || cooked === undefined
+            ? { found: false }
+            : { found: true, value: cooked };
+    }
+    return { found: false };
+};
 /** Read an identifier or literal property name without evaluating syntax. */
 export const propertyName = (node) => {
     if (t.isIdentifier(node))

package/dist/{application/javascript/JavaScriptReturnShapeProjection.js → domain/javascript/javascriptExportReturnShapeProjection.js}

@@ -1,7 +1,7 @@
-import { jsonObjectSchema, jsonValueSchema } from "../../domain/jsonValue.js";
-import { partialApplicationCoverage, truncatedApplicationCoverage, } from "../../domain/javascript/javascriptApplicationEvidenceSchemas.js";
-import { flattenSemanticReturnValue } from "../../domain/javascript/javascriptSemanticReturns.js";
-/** Project one exact export/callable link into shallow bounded graph values. */
+import { jsonObjectSchema, jsonValueSchema } from "../jsonValue.js";
+import { partialApplicationCoverage, truncatedApplicationCoverage, } from "./javascriptApplicationEvidenceSchemas.js";
+import { flattenSemanticReturnValue } from "./javascriptSemanticReturns.js";
+/** Project one exact export/callable link into inert return-shape observations. */
 export const projectJavaScriptExportReturnShapes = (input) => {
     if (input.link.callableId === null || input.link.exportedName === null)
         return null;

package/dist/domain/javascript/javascriptExportShapeComparison.js

@@ -2,7 +2,7 @@ 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, hasPartialJavaScriptExportPropertyCoverage, pairJavaScriptExportShapeVariants, } from "./javascriptExportShapeVariants.js";
+import { buildJavaScriptExportShapeChanges, buildJavaScriptExportShapeInventories, hasPartialJavaScriptExportPropertyCoverage, pairJavaScriptExportShapeVariants, } from "./javascriptExportShapeVariants.js";
 /** Compare exact selected export return shapes without executing JavaScript. */
 export const compareJavaScriptExportShapes = (input) => {
     const left = selectJavaScriptExport(input.left);
@@ -21,6 +21,11 @@ export const compareJavaScriptExportShapes = (input) => {
     }));
     const changes = allChanges;
     const omittedChanges = 0;
+    const propertyInventories = buildJavaScriptExportShapeInventories({
+        pairing,
+        leftShapes: leftRetained.shapes,
+        rightShapes: rightRetained.shapes,
+    });
     const coverage = comparisonCoverage({
         input,
         left,
@@ -35,6 +40,7 @@ export const compareJavaScriptExportShapes = (input) => {
     const semantic = {
         left: left.selection,
         right: right.selection,
+        property_inventories: propertyInventories,
         summary: summarize(allChanges),
         changes,
         coverage,

package/dist/domain/javascript/javascriptExportShapeComparisonIdentity.js

@@ -1,6 +1,11 @@
 import { createHash } from "node:crypto";
 import canonicalize from "canonicalize";
-/** Canonically encode one export-shape comparison value. */
+/**
+ * Canonically encode one export-shape comparison value.
+ *
+ * Comparison identifiers hash the full result semantics, including each
+ * change's presence object and the per-variant property inventories.
+ */
 export const canonicalExportShapeValue = (value) => {
     const encoded = canonicalize(value);
     if (encoded === undefined)

package/dist/domain/javascript/javascriptExportShapeComparisonSchemas.js

@@ -67,7 +67,10 @@ export const compareJavaScriptExportShapesInputSchema = z
             message: "JavaScript export shape Evidence must be distinct",
         });
 });
-const projectedReturnFieldShape = { path: jsonPointerSchema };
+const projectedReturnFieldShape = {
+    path: jsonPointerSchema,
+    presence: z.enum(["present", "absent", "unknown-coverage"]),
+};
 const projectedReturnFieldSchema = z.discriminatedUnion("state", [
     z.strictObject({
         ...projectedReturnFieldShape,
@@ -209,11 +212,20 @@ const discriminantSchema = z.strictObject({
     path: jsonPointerSchema,
     value: semanticPrimitiveSchema,
 });
+const propertyPresenceSchema = z.enum([
+    "present",
+    "absent",
+    "unknown-coverage",
+]);
 const comparisonChangeSchema = z.strictObject({
     change_id: prefixedDigestSchema("jesc_change"),
     status: z.enum(["added", "removed", "changed", "unknown"]),
     path: jsonPointerSchema,
     discriminant: discriminantSchema.nullable(),
+    presence: z.strictObject({
+        left: propertyPresenceSchema,
+        right: propertyPresenceSchema,
+    }),
     left: valueAvailabilitySchema,
     right: valueAvailabilitySchema,
     left_source_range: sourceRangeSchema.nullable(),
@@ -221,11 +233,27 @@ const comparisonChangeSchema = z.strictObject({
     evidence_links: z.array(evidenceIdSchema).length(2),
     limitations: z.array(textSchema),
 });
+/** One change row; presence is required even when values stay unknown. */
+export const javaScriptExportShapeComparisonChangeSchema = comparisonChangeSchema;
+const inventoryPropertyCoverageSchema = z.strictObject({
+    path: jsonPointerSchema,
+    status: z.enum(["complete", "partial"]),
+});
+const propertyInventorySchema = z.strictObject({
+    side: z.enum(["left", "right"]),
+    variant_index: z.number().int().nonnegative(),
+    discriminant: discriminantSchema.nullable(),
+    paired: z.boolean(),
+    source_range: sourceRangeSchema,
+    properties: z.array(jsonPointerSchema),
+    property_coverage: z.array(inventoryPropertyCoverageSchema),
+});
 /** Static export-return comparison with explicit unknown semantics. */
 export const javaScriptExportShapeComparisonResultSchema = z.strictObject({
     comparison_id: prefixedDigestSchema("jesc"),
     left: selectorResultSchema,
     right: selectorResultSchema,
+    property_inventories: z.array(propertyInventorySchema),
     summary: z.strictObject({
         added: z.number().int().min(0),
         removed: z.number().int().min(0),

package/dist/domain/javascript/javascriptExportShapeSelection.js

@@ -41,11 +41,11 @@ export const selectJavaScriptExport = (side) => {
         limitations: [],
     };
 };
-/** Retain every projected return variant. */
-export const retainJavaScriptExportShapes = (selection) => {
-    const shapes = selection.projection?.static_return_shapes ?? [];
-    return { shapes, omitted: 0 };
-};
+/** Retain every authenticated variant with its explicit slot presence. */
+export const retainJavaScriptExportShapes = (selection) => ({
+    shapes: selection.projection?.static_return_shapes ?? [],
+    omitted: 0,
+});
 const selectorBase = (side, candidates) => ({
     evidence_id: side.evidenceId,
     graph_id: side.graph.graph_id,

package/dist/domain/javascript/javascriptExportShapeVariants.js

@@ -1,5 +1,9 @@
 import { canonicalExportShapeValue, digestExportShapeValue, } from "./javascriptExportShapeComparisonIdentity.js";
 import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
+const UNKNOWN_COVERAGE_PRESENCE = {
+    left: "unknown-coverage",
+    right: "unknown-coverage",
+};
 /** Pair variants only through reciprocal unique exact literal discriminants. */
 export const pairJavaScriptExportShapeVariants = (left, right) => {
     const leftKeys = discriminantOccurrences(left);
@@ -61,12 +65,41 @@ export const buildJavaScriptExportShapeChanges = (input) => {
     });
     return [...paired, ...unpairedLeft, ...unpairedRight];
 };
+/** List observed property names per retained variant, including unknown values. */
+export const buildJavaScriptExportShapeInventories = (input) => {
+    const leftPairs = new Map(input.pairing.pairs.map((pair) => [pair.leftIndex, pair]));
+    const rightPairs = new Map(input.pairing.pairs.map((pair) => [pair.rightIndex, pair]));
+    return [
+        ...input.leftShapes.map((shape, index) => inventoryFor("left", index, shape, leftPairs.get(index))),
+        ...input.rightShapes.map((shape, index) => inventoryFor("right", index, shape, rightPairs.get(index))),
+    ];
+};
+const inventoryFor = (side, variantIndex, shape, pair) => ({
+    side,
+    variant_index: variantIndex,
+    discriminant: pair?.discriminant ?? null,
+    paired: pair !== undefined,
+    source_range: shape.source_range,
+    properties: uniqueSorted([
+        ...shape.fields
+            .filter((field) => fieldPresence(shape, field, field.path) === "present")
+            .map(({ path }) => path),
+        ...shape.property_coverage.map(({ path }) => path),
+    ]).filter((path) => path !== ""),
+    property_coverage: shape.property_coverage.map(({ path, status }) => ({
+        path,
+        status,
+    })),
+});
 /** Report whether any retained shape lacks complete property coverage. */
-export const hasPartialJavaScriptExportPropertyCoverage = (shapes) => shapes.some((shape) => shape.property_coverage.some(({ status }) => status === "partial"));
+export const hasPartialJavaScriptExportPropertyCoverage = (shapes) => shapes.some((shape) => shape.property_coverage.some(({ status }) => status === "partial") ||
+    shape.fields.some((field) => fieldPresence(shape, field, field.path) === "unknown-coverage"));
 const discriminantOccurrences = (shapes) => {
     const output = new Map();
     shapes.forEach((shape, index) => {
         for (const field of shape.fields) {
+            if (fieldPresence(shape, field, field.path) !== "present")
+                continue;
             const value = literalValue(field);
             if (!value.found)
                 continue;
@@ -111,6 +144,7 @@ const selectionUnknownChange = (input) => changeWithId({
     status: "unknown",
     path: "",
     discriminant: null,
+    presence: UNKNOWN_COVERAGE_PRESENCE,
     left: selectionAvailability(input.leftSelection.selection, "left"),
     right: selectionAvailability(input.rightSelection.selection, "right"),
     left_source_range: null,
@@ -124,6 +158,7 @@ const emptyShapeUnknownChange = (input) => changeWithId({
     status: "unknown",
     path: "",
     discriminant: null,
+    presence: UNKNOWN_COVERAGE_PRESENCE,
     left: emptyShapeAvailability(input.leftShapes, "left"),
     right: emptyShapeAvailability(input.rightShapes, "right"),
     left_source_range: null,
@@ -159,6 +194,10 @@ const diffPair = (left, right, discriminant, evidenceLinks) => {
                 status,
                 path,
                 discriminant,
+                presence: {
+                    left: fieldPresence(left, leftField, path),
+                    right: fieldPresence(right, rightField, path),
+                },
                 left: fieldAvailability(leftField),
                 right: fieldAvailability(rightField),
                 left_source_range: left.source_range,
@@ -181,29 +220,42 @@ const fieldAtPath = (shape, fields, path) => {
         return undefined;
     return {
         path,
+        presence: "present",
         state: "unknown",
         value: null,
         reason: "A static container is retained at this path, but no primitive field value is projected.",
     };
 };
 const fieldChangeStatus = ({ leftShape, rightShape, path, leftField, rightField, }) => {
-    if (leftField !== undefined && rightField !== undefined) {
-        if (canonicalExportShapeValue(leftField) ===
+    const leftPresence = fieldPresence(leftShape, leftField, path);
+    const rightPresence = fieldPresence(rightShape, rightField, path);
+    if (leftField !== undefined &&
+        rightField !== undefined &&
+        canonicalExportShapeValue(leftField) ===
             canonicalExportShapeValue(rightField))
-            return null;
+        return null;
+    if (leftPresence === "absent" && rightPresence === "absent")
+        return null;
+    if (leftPresence === "unknown-coverage" ||
+        rightPresence === "unknown-coverage")
+        return "unknown";
+    if (leftPresence === "absent")
+        return "added";
+    if (rightPresence === "absent")
+        return "removed";
+    if (leftField !== undefined && rightField !== undefined) {
         return leftField.state === "unknown" || rightField.state === "unknown"
             ? "unknown"
             : "changed";
     }
-    const present = leftField ?? rightField;
-    if (present === undefined)
-        return null;
-    const parent = parentPointer(path);
-    const parentsComplete = propertyCoverageComplete(leftShape, parent) &&
-        propertyCoverageComplete(rightShape, parent);
-    if (present.state === "unknown" || !parentsComplete)
-        return "unknown";
-    return leftField === undefined ? "added" : "removed";
+    return null;
+};
+const fieldPresence = (shape, field, path) => {
+    if (field !== undefined)
+        return field.presence;
+    return propertyCoverageComplete(shape, parentPointer(path))
+        ? "absent"
+        : "unknown-coverage";
 };
 const propertyCoverageComplete = (shape, path) => path !== null &&
     shape.property_coverage.some((coverage) => coverage.path === path && coverage.status === "complete");
@@ -214,7 +266,7 @@ const parentPointer = (path) => {
     return separator < 0 ? null : path.slice(0, separator);
 };
 const fieldAvailability = (field) => {
-    if (field === undefined)
+    if (field === undefined || field.presence === "absent")
         return { availability: "absent" };
     if (field.state === "unknown")
         return {
@@ -245,6 +297,7 @@ const unpairedChange = (side, shape, evidenceLinks) => changeWithId({
     status: "unknown",
     path: "",
     discriminant: null,
+    presence: UNKNOWN_COVERAGE_PRESENCE,
     left: {
         availability: "unknown",
         reason: side === "left"

package/dist/domain/javascript/javascriptFeatureSeed.js

@@ -62,6 +62,16 @@ const candidateFields = (node, seedKind) => {
                         value: observation.label,
                     },
                 ]),
+            ...(observation.source_map_reference !== null &&
+                observation.source_map_reference.resolution.kind !== "unresolved"
+                ? [
+                    {
+                        basis: "property",
+                        field: `observations[${String(index)}].source_map_reference.resolution.path`,
+                        value: observation.source_map_reference.resolution.path,
+                    },
+                ]
+                : []),
             ...propertyFields(observation.properties, `observations[${String(index)}].properties`),
         ]),
     ];
@@ -89,6 +99,7 @@ const relevantFields = {
         ".path",
         ".source",
         ".original_source",
+        ".source_root",
         ".exports",
     ],
     "native-export": [".label", ".key", ".requested_members", ".members"],
@@ -104,6 +115,15 @@ const identityFields = (node) => {
                 field: "identity.original_source",
                 value: identity.original_source,
             },
+            ...(identity.source_root === null
+                ? []
+                : [
+                    {
+                        basis: "identity",
+                        field: "identity.source_root",
+                        value: identity.source_root,
+                    },
+                ]),
         ];
     if (identity.strategy === "canonical-path")
         return [

package/dist/domain/javascript/javascriptFeatureTraversal.js

@@ -1,4 +1,3 @@
-import {} from "./javascriptApplicationGraph.js";
 import { compareCodePoints } from "../canonicalOrdering.js";
 /** Traverse a JAG without treating edge inference as observed reachability. */
 export const traverseApplicationFeature = (graph, seedNodeIds, direction) => {

package/dist/domain/javascript/javascriptNativeHandoff.js

@@ -1,5 +1,5 @@
 import { compareCodePoints } from "../canonicalOrdering.js";
-import {} from "./javascriptApplicationGraph.js";
+import {} from "./javascriptApplicationGraphSchemas.js";
 /** Build provider-neutral addon targets and link exact-subject native Evidence. */
 export const buildJavaScriptNativeHandoffs = (nodes, edges, nativeEvidence) => {
     const nodeById = new Map(nodes.map((node) => [node.node_id, node]));

package/dist/domain/javascript/javascriptRecovery.js

@@ -1,16 +1,11 @@
 import { z } from "zod";
 import { digestSchema } from "../digests.js";
 import { analyzeJavaScriptApplicationInputSchema } from "./javascriptApplicationAnalysis.js";
+import { localPathStringSchema } from "../localPath.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"),
+    path: localPathStringSchema.describe("Absolute path to a UTF-8 JavaScript file; never executed"),
+    output_directory: localPathStringSchema.describe("Absolute absent output directory; parent must exist"),
     extraction_mode: z
         .enum(["structural", "heuristic", "inspection"])
         .default("structural")

package/dist/domain/javascript/javascriptRuntimeLoadState.js

@@ -1,4 +1,3 @@
-import {} from "./javascriptApplicationGraph.js";
 import { uniqueSorted } from "../canonicalOrdering.js";
 import { createStaticRuntimeScope, mappedRuntimePaths, staticNodeWithinRuntimeScope, } from "./javascriptRuntimeStaticCandidates.js";
 /** Classify static code presence without claiming bundled module execution. */

package/dist/domain/javascript/javascriptRuntimeObservation.js

@@ -77,8 +77,16 @@ const javascriptRuntimeScriptSchema = z.strictObject({
     location: javascriptRuntimeLocationSchema,
     execution_context_key: z.string().nullable(),
     cdp_hash: z.string().nullable(),
-    length: z.number().int().min(0),
-    is_module: z.boolean(),
+    length: z
+        .number()
+        .int()
+        .min(0)
+        .nullable()
+        .describe("Producer-reported script length; null when unavailable."),
+    is_module: z
+        .boolean()
+        .nullable()
+        .describe("Producer-reported module classification; null when unavailable."),
     status: z.literal("observed-loaded"),
 });
 const javascriptRuntimeContextSchema = z.strictObject({

package/dist/domain/javascript/javascriptRuntimeReconciliationMatching.js

@@ -1,4 +1,4 @@
-import { createJavaScriptApplicationEdge, } from "./javascriptApplicationGraph.js";
+import { createJavaScriptApplicationEdge } from "./javascriptApplicationGraph.js";
 import { canonicalDigest } from "../comparisonSemantics.js";
 import { compareCodePoints } from "../canonicalOrdering.js";
 import { mappedRuntimePaths, } from "./javascriptRuntimeStaticCandidates.js";

package/dist/domain/javascript/javascriptRuntimeReconciliationParsing.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
-import { browserAllowedOriginsSchema, browserEndpointSchema, webPageInspectionSchema, } from "../browserObservation.js";
+import { browserAllowedOriginsSchema, browserEndpointSchema, } from "../browserObservation.js";
+import { webPageInspectionSchema, } from "../browserObservationSchemas.js";
 import { classifyBrowserCompleteness, } from "../browserCompleteness.js";
 import { electronPageInspectionSchema, } from "./electronObservation.js";
 import { javascriptRuntimeObservationSchema, javascriptRuntimeKindSchema, } from "./javascriptRuntimeObservation.js";
@@ -160,7 +161,7 @@ const normalizeV8Inspection = (result) => ({
             script_key: script.script_key,
             frame_id: script.execution_context_key,
             ...runtimeLocation(script.location),
-            cdp_hash: script.cdp_hash ?? "",
+            cdp_hash: script.cdp_hash,
             length: script.length,
             is_module: script.is_module,
             language: null,

package/dist/domain/javascript/javascriptRuntimeStaticCandidates.js

@@ -1,5 +1,4 @@
 import { posix, relative, win32 } from "node:path";
-import {} from "./javascriptApplicationGraph.js";
 import { compareCodePoints, uniqueSorted } from "../canonicalOrdering.js";
 /** Index statically reconstructed entities that can receive runtime matches. */
 export const collectStaticRuntimeCandidates = (layers) => layers