rea-agents 3.2.1 → 4.0.1

package/dist/domain/javascriptApplicationVersionItems.js

@@ -1,5 +1,4 @@
-import { createHash } from "node:crypto";
-import canonicalize from "canonicalize";
+import { absenceClaimable, canonicalDigest, canonicalJson, } from "./comparisonSemantics.js";
 import { compareCodePoints, } from "./javascriptApplicationGraph.js";
 /** Classify matched, unmatched, and ambiguous nodes without inventing absence. */
 export const classifyJavaScriptApplicationVersions = (matching, context) => {
@@ -83,7 +82,7 @@ const leftOnlyItem = (node, candidateNodeIds, context) => {
             dimensions: ["availability"],
             limitations: [AMBIGUOUS_MATCH_LIMITATION],
         });
-    const absenceObserved = context.rightGraph.coverage.status === "complete";
+    const absenceObserved = absenceClaimable(context.rightGraph.coverage);
     return itemWithId({
         ...common,
         status: absenceObserved ? "removed" : "unknown",
@@ -118,7 +117,7 @@ const rightOnlyItem = (node, candidateNodeIds, context) => {
             dimensions: ["availability"],
             limitations: [AMBIGUOUS_MATCH_LIMITATION],
         });
-    const absenceObserved = context.leftGraph.coverage.status === "complete";
+    const absenceObserved = absenceClaimable(context.leftGraph.coverage);
     return itemWithId({
         ...common,
         status: absenceObserved ? "added" : "unknown",
@@ -180,9 +179,10 @@ const changedDimensions = (pair, context) => {
         rightContent !== null &&
         leftContent !== rightContent)
         dimensions.push("content");
-    if (canonical(locations(pair.left)) !== canonical(locations(pair.right)))
+    if (canonicalJson(locations(pair.left)) !== canonicalJson(locations(pair.right)))
         dimensions.push("location");
-    if (canonical(properties(pair.left)) !== canonical(properties(pair.right)))
+    if (canonicalJson(properties(pair.left)) !==
+        canonicalJson(properties(pair.right)))
         dimensions.push("properties");
     if (relationshipSignature(pair.left, "left", context) !==
         relationshipSignature(pair.right, "right", context))
@@ -201,10 +201,10 @@ const contentIdentity = (node) => {
 };
 const locations = (node) => node.observations
     .map(({ evidence }) => evidence.location.available ? evidence.location.value : evidence.location)
-    .sort((left, right) => compareCodePoints(canonical(left), canonical(right)));
+    .sort((left, right) => compareCodePoints(canonicalJson(left), canonicalJson(right)));
 const properties = (node) => node.observations
     .map(({ label, properties: values }) => ({ label, properties: values }))
-    .sort((left, right) => compareCodePoints(canonical(left), canonical(right)));
+    .sort((left, right) => compareCodePoints(canonicalJson(left), canonicalJson(right)));
 const relationshipSignature = (node, side, context) => {
     const graph = side === "left" ? context.leftGraph : context.rightGraph;
     const paired = side === "left" ? context.pairByLeft : context.pairByRight;
@@ -232,7 +232,7 @@ const relationshipSignature = (node, side, context) => {
             ];
         return [];
     });
-    return canonical(signatures.sort(compareCodePoints));
+    return canonicalJson(signatures.sort(compareCodePoints));
 };
 const edgeSignature = (context) => {
     const mapped = context.paired.get(context.neighborId);
@@ -289,12 +289,6 @@ const stringProperty = (node, key) => {
     ];
     return values.length === 1 ? (values[0] ?? null) : null;
 };
-const graphsComplete = (context) => context.leftGraph.coverage.status === "complete" &&
-    context.rightGraph.coverage.status === "complete";
-const canonical = (value) => {
-    const encoded = canonicalize(value);
-    if (encoded === undefined)
-        throw new TypeError("Application version item could not canonicalize data");
-    return encoded;
-};
-const digestCanonical = (value) => createHash("sha256").update(canonical(value)).digest("hex");
+const graphsComplete = (context) => absenceClaimable(context.leftGraph.coverage) &&
+    absenceClaimable(context.rightGraph.coverage);
+const digestCanonical = (value) => canonicalDigest(value, "Application version item");

package/dist/domain/javascriptAstValues.js

@@ -7,3 +7,7 @@ export const propertyName = (node) => {
         return String(node.value);
     return "";
 };
+/** Read a property name only when its syntax commits to one exact key. */
+export const semanticStaticPropertyName = (property, computed) => computed && !t.isStringLiteral(property) && !t.isNumericLiteral(property)
+    ? ""
+    : propertyName(property);

package/dist/domain/javascriptExportShapeComparison.js

@@ -40,11 +40,6 @@ export const compareJavaScriptExportShapes = (input) => {
         coverage,
         evidence_links: evidenceLinks,
         limitations,
-        runtime_validation: {
-            recommended_tool: "run_controlled_replay",
-            automatically_started: false,
-            required_for: "runtime-semantics",
-        },
     };
     return javaScriptExportShapeComparisonResultSchema.parse({
         ...semantic,
@@ -116,7 +111,7 @@ const comparisonLimitations = (left, right, status) => uniqueSorted([
     "Return shapes are inferred from inert syntax and do not prove runtime behavior.",
     "Return variants are paired only by unique exact literal discriminants, never by source order.",
     "Dynamic values, incomplete object coverage, and ambiguous variants remain unknown.",
-    "Controlled replay is recommended separately for runtime semantics and was not started.",
+    "This static comparison cannot establish runtime semantics; run behavioral probes directly against the relevant application versions when that evidence is required.",
     ...left.limitations,
     ...right.limitations,
     ...(status === "truncated"

package/dist/domain/javascriptExportShapeComparisonSchemas.js

@@ -1,8 +1,9 @@
 import { z } from "zod";
 import { evidenceSchema } from "./evidence.js";
-const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
-const graphIdSchema = z.string().regex(/^jag_[a-f0-9]{64}$/u);
-const nodeIdSchema = z.string().regex(/^jag_node_[a-f0-9]{64}$/u);
+import { prefixedDigestSchema } from "./../domain/digests.js";
+const evidenceIdSchema = prefixedDigestSchema("ev");
+const graphIdSchema = prefixedDigestSchema("jag");
+const nodeIdSchema = prefixedDigestSchema("jag_node");
 const textSchema = z.string().min(1);
 const selectorTextSchema = textSchema;
 const semanticPrimitiveSchema = z.union([
@@ -209,7 +210,7 @@ const discriminantSchema = z.strictObject({
     value: semanticPrimitiveSchema,
 });
 const comparisonChangeSchema = z.strictObject({
-    change_id: z.string().regex(/^jesc_change_[a-f0-9]{64}$/u),
+    change_id: prefixedDigestSchema("jesc_change"),
     status: z.enum(["added", "removed", "changed", "unknown"]),
     path: jsonPointerSchema,
     discriminant: discriminantSchema.nullable(),
@@ -222,7 +223,7 @@ const comparisonChangeSchema = z.strictObject({
 });
 /** Static export-return comparison with explicit unknown semantics. */
 export const javaScriptExportShapeComparisonResultSchema = z.strictObject({
-    comparison_id: z.string().regex(/^jesc_[a-f0-9]{64}$/u),
+    comparison_id: prefixedDigestSchema("jesc"),
     left: selectorResultSchema,
     right: selectorResultSchema,
     summary: z.strictObject({
@@ -262,9 +263,4 @@ export const javaScriptExportShapeComparisonResultSchema = z.strictObject({
     }),
     evidence_links: z.array(evidenceIdSchema).length(2),
     limitations: z.array(textSchema),
-    runtime_validation: z.strictObject({
-        recommended_tool: z.literal("run_controlled_replay"),
-        automatically_started: z.literal(false),
-        required_for: z.literal("runtime-semantics"),
-    }),
 });

package/dist/domain/javascriptExportShapeVariants.js

@@ -140,8 +140,8 @@ const diffPair = (left, right, discriminant, evidenceLinks) => {
     const rightFields = new Map(right.fields.map((field) => [field.path, field]));
     const paths = uniqueSorted([...leftFields.keys(), ...rightFields.keys()]);
     return paths.flatMap((path) => {
-        const leftField = leftFields.get(path);
-        const rightField = rightFields.get(path);
+        const leftField = fieldAtPath(left, leftFields, path);
+        const rightField = fieldAtPath(right, rightFields, path);
         const status = fieldChangeStatus({
             leftShape: left,
             rightShape: right,
@@ -170,6 +170,19 @@ const diffPair = (left, right, discriminant, evidenceLinks) => {
         ];
     });
 };
+const fieldAtPath = (shape, fields, path) => {
+    const field = fields.get(path);
+    if (field !== undefined)
+        return field;
+    if (!shape.property_coverage.some((coverage) => coverage.path === path))
+        return undefined;
+    return {
+        path,
+        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) ===

package/dist/domain/javascriptFeatureTraceSchemas.js

@@ -1,10 +1,11 @@
 import { z } from "zod";
 import { evidenceSchema, providerSchema } from "./evidence.js";
 import { javascriptApplicationGraphSchema } from "./javascriptApplicationGraph.js";
-const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
-const nodeIdSchema = z.string().regex(/^jag_node_[a-f0-9]{64}$/u);
-const edgeIdSchema = z.string().regex(/^jag_edge_[a-f0-9]{64}$/u);
+import { digestSchema } from "./../domain/digests.js";
+import { prefixedDigestSchema } from "./../domain/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({
@@ -45,7 +46,7 @@ const seedMatchSchema = z.strictObject({
     field: z.string().min(1),
 });
 const tracePathSchema = z.strictObject({
-    path_id: z.string().regex(/^jatp_[a-f0-9]{64}$/u),
+    path_id: prefixedDigestSchema("jatp"),
     start_node_id: nodeIdSchema,
     end_node_id: nodeIdSchema,
     end_kind: z.string().min(1),
@@ -73,9 +74,9 @@ const nativeHandoffSchema = z.strictObject({
 });
 /** Evidence-preserving complete reachable subgraph and native-analysis handoffs. */
 export const applicationFeatureTraceResultSchema = z.strictObject({
-    trace_id: z.string().regex(/^jatr_[a-f0-9]{64}$/u),
+    trace_id: prefixedDigestSchema("jatr"),
     source_evidence_id: evidenceIdSchema,
-    source_graph_id: z.string().regex(/^jag_[a-f0-9]{64}$/u),
+    source_graph_id: prefixedDigestSchema("jag"),
     seed: applicationFeatureSeedSchema,
     direction: z.enum(["outgoing", "incoming", "both"]),
     seed_matches: z.array(seedMatchSchema),

package/dist/domain/javascriptRuntimeObservation.js

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import { browserEndpointSchema } from "./browserObservation.js";
+import { prefixedDigestSchema } from "./../domain/digests.js";
 const observationTextSchema = z.string().min(1);
 const runtimeEndpoint = {
     inspector_endpoint: browserEndpointSchema,
@@ -44,11 +45,22 @@ export const javascriptRuntimeLocationSchema = z.discriminatedUnion("kind", [
         specifier: z.string().min(1),
     }),
 ]);
+/** Discovery metadata can identify an endpoint target without verifying its file location. */
+export const javascriptRuntimeUnresolvedLocationSchema = z.strictObject({
+    kind: z.literal("unresolved"),
+    reported_url: z.string().min(1),
+    reason: z.literal("unverifiable-file-location"),
+});
+/** Verified locations and explicitly unresolved discovery metadata. */
+export const javascriptRuntimeTargetLocationSchema = z.union([
+    javascriptRuntimeLocationSchema,
+    javascriptRuntimeUnresolvedLocationSchema,
+]);
 const javascriptRuntimeTargetSchema = z.strictObject({
     target_id: z.string().min(1),
     protocol_type: z.string().min(1),
     attached: z.boolean(),
-    location: javascriptRuntimeLocationSchema,
+    location: javascriptRuntimeTargetLocationSchema,
 });
 /** Complete V8 Inspector target inventory exposed by the selected endpoint. */
 export const javascriptRuntimeTargetListSchema = z.strictObject({
@@ -61,7 +73,7 @@ export const javascriptRuntimeTargetListSchema = z.strictObject({
     limitations: z.array(observationTextSchema),
 });
 const javascriptRuntimeScriptSchema = z.strictObject({
-    script_key: z.string().regex(/^v8_script_[a-f0-9]{64}$/u),
+    script_key: prefixedDigestSchema("v8_script"),
     location: javascriptRuntimeLocationSchema,
     execution_context_key: z.string().nullable(),
     cdp_hash: z.string().nullable(),

package/dist/domain/javascriptRuntimeReconciliationMatching.js

@@ -13,6 +13,14 @@ export const reconcileRuntimeEntities = (input) => {
     };
 };
 const reconcileEntity = (entity, index, layers) => {
+    if (entity.location.kind === "unresolved")
+        return unresolved(entity, {
+            status: "unknown",
+            basis: "none",
+            confidence: "unknown",
+            reason: "runtime-location-unresolved",
+            candidates: [],
+        });
     const locations = candidatesWithLocation(entity, index, layers);
     if (entity.sourceSha256 !== null) {
         const content = index.byCategoryDigest.get(categoryDigestKey(entity.staticKind, entity.sourceSha256)) ?? [];

package/dist/domain/javascriptRuntimeReconciliationParsing.js

@@ -156,7 +156,9 @@ const normalizeV8Inspection = (result) => ({
         type: result.target.protocol_type,
         title: result.target.runtime_kind,
         attached: result.target.attached,
-        ...runtimeLocation(result.target.location),
+        ...(result.target.location.kind === "unresolved"
+            ? { unresolved_location: result.target.location }
+            : runtimeLocation(result.target.location)),
     },
     frames: [],
     scripts: {
@@ -229,7 +231,7 @@ const assertRuntimeParameters = (evidence, expected) => {
         if (!parameters.allowed_origins.includes(expected.targetOrigin))
             throw new TypeError("Browser Evidence target is outside its recorded origin scope");
         if (expected.sourceIncluded && !parameters.include_script_sources)
-            throw new TypeError("Runtime Evidence contains source without source-capture approval");
+            throw new TypeError("Runtime Evidence contains source without source-capture selection");
         return;
     }
     const parameters = z.object(common).passthrough().parse(evidence.parameters);

package/dist/domain/javascriptRuntimeReconciliationResult.js

@@ -44,9 +44,11 @@ const captureSummaries = (captures, runtime) => captures.map((capture) => {
         kind: capture.kind,
         target_node_id: targetNode.node_id,
         target_key: capture.inspection.target.target_id,
-        target_location: "url" in capture.inspection.target
-            ? capture.inspection.target.url
-            : capture.inspection.target.file_path,
+        target_location: "unresolved_location" in capture.inspection.target
+            ? capture.inspection.target.unresolved_location
+            : "url" in capture.inspection.target
+                ? capture.inspection.target.url
+                : capture.inspection.target.file_path,
         frames: capture.inspection.frames.length,
         scripts: capture.inspection.scripts.items.length,
         workers: capture.inspection.workers.length,
@@ -74,7 +76,7 @@ const sourceMapAuthority = (input) => ({
         (capture.kind === "browser"
             ? capture.inspection.scripts.items.filter(({ source_map_url: url }) => url !== null).length
             : 0), 0),
-    limitation: "Source-map declarations and approved original-source reads retain separate static authority and are not used as primary runtime byte matches.",
+    limitation: "Source-map declarations and original-source content retain separate static authority and are not used as primary runtime byte matches.",
 });
 const reconciliationCoverage = (input, completion) => ({
     status: completion.outputTruncated || completion.inputStatus === "truncated"

package/dist/domain/javascriptRuntimeReconciliationRuntime.js

@@ -30,9 +30,14 @@ const projectCapture = (capture) => {
 };
 const targetEntity = (capture) => {
     const target = capture.inspection.target;
-    const location = "url" in target
-        ? { kind: "url", value: target.url }
-        : { kind: "file", value: target.file_path };
+    const location = "unresolved_location" in target
+        ? {
+            kind: "unresolved",
+            value: target.unresolved_location.reported_url,
+        }
+        : "url" in target
+            ? { kind: "url", value: target.url }
+            : { kind: "file", value: target.file_path };
     return runtimeEntity(capture, {
         kind: "target",
         nodeKind: "target",
@@ -46,7 +51,13 @@ const targetEntity = (capture) => {
         label: target.title,
         properties: {
             runtime_type: target.type,
-            location: location.value,
+            ...(location.kind === "unresolved"
+                ? {
+                    reported_url: location.value,
+                    location_kind: "unresolved",
+                    location_reason: "unverifiable-file-location",
+                }
+                : { location: location.value }),
             attached: target.attached,
         },
         section: "target",

package/dist/domain/javascriptRuntimeReconciliationSchemas.js

@@ -1,10 +1,11 @@
-import { isAbsolute, resolve } from "node:path";
 import { z } from "zod";
 import { evidenceSchema } from "./evidence.js";
+import { javascriptRuntimeUnresolvedLocationSchema } from "./javascriptRuntimeObservation.js";
 import { compareCodePoints, javascriptApplicationGraphSchema, } from "./javascriptApplicationGraph.js";
-const digestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
-const evidenceIdSchema = z.string().regex(/^ev_[a-f0-9]{64}$/u);
-const nodeIdSchema = z.string().regex(/^jag_node_[a-f0-9]{64}$/u);
+import { digestSchema } from "./../domain/digests.js";
+import { prefixedDigestSchema } from "./../domain/digests.js";
+const evidenceIdSchema = prefixedDigestSchema("ev");
+const nodeIdSchema = prefixedDigestSchema("jag_node");
 const boundedTextSchema = z.string().min(1);
 const safePrefixSchema = z
     .string()
@@ -14,11 +15,7 @@ const safePrefixSchema = z
         value.split("/").every((part) => !["", ".", ".."].includes(part))), "Artifact prefix must be empty or a safe relative POSIX path");
 const runtimeFileMappingSchema = z.strictObject({
     kind: z.literal("file-root"),
-    root: z
-        .string()
-        .min(1)
-        .refine(isAbsolute, "Runtime file mapping root must be absolute")
-        .overwrite((value) => resolve(value)),
+    root: z.string().min(1),
     artifact_prefix: safePrefixSchema.default(""),
 });
 const runtimeUrlMappingSchema = z.strictObject({
@@ -54,7 +51,7 @@ const runtimeLocationMappingSchema = z.discriminatedUnion("kind", [
     runtimeUrlMappingSchema,
 ]);
 const staticLayerSchema = z.strictObject({
-    role: z.enum(["application", "cache", "assets"]),
+    role: z.enum(["application", "cache", "assets"]).default("application"),
     analysis: evidenceSchema,
     runtime_mappings: z
         .array(runtimeLocationMappingSchema)
@@ -101,10 +98,10 @@ export const reconcileJavaScriptRuntimeInputSchema = z
         });
 });
 const layerSummarySchema = z.strictObject({
-    layer_id: z.string().regex(/^jrl_[a-f0-9]{64}$/u),
+    layer_id: prefixedDigestSchema("jrl"),
     role: z.enum(["application", "cache", "assets"]),
     evidence_id: evidenceIdSchema,
-    graph_id: z.string().regex(/^jag_[a-f0-9]{64}$/u),
+    graph_id: prefixedDigestSchema("jag"),
     root_artifact_sha256: digestSchema,
     input_path: z.string().min(1),
     format: z.enum(["asar", "directory"]),
@@ -116,7 +113,10 @@ const captureSummarySchema = z.strictObject({
     kind: z.enum(["browser", "electron", "v8-inspector", "electron-active"]),
     target_node_id: nodeIdSchema,
     target_key: boundedTextSchema,
-    target_location: z.string().min(1),
+    target_location: z
+        .string()
+        .min(1)
+        .or(javascriptRuntimeUnresolvedLocationSchema),
     frames: z.number().int().min(0),
     scripts: z.number().int().min(0),
     workers: z.number().int().min(0),
@@ -130,12 +130,13 @@ const reconciliationReasonSchema = z.enum([
     "captured-content-disagrees-with-static-location",
     "no-static-content-match",
     "no-authorized-location-mapping",
+    "runtime-location-unresolved",
     "runtime-frame-unattributed",
     "static-or-runtime-coverage-incomplete",
     "reconciliation-limit-reached",
 ]);
 const reconciliationItemShape = {
-    reconciliation_id: z.string().regex(/^jrr_item_[a-f0-9]{64}$/u),
+    reconciliation_id: prefixedDigestSchema("jrr_item"),
     entity_kind: z.enum(["target", "frame", "script", "worker"]),
     runtime_evidence_id: evidenceIdSchema,
     runtime_node_id: nodeIdSchema,
@@ -152,14 +153,14 @@ const reconciliationItemShape = {
     reason: reconciliationReasonSchema,
     candidate_static_count: z.number().int().min(0),
     candidate_static_nodes: z.array(z.strictObject({
-        static_layer_id: z.string().regex(/^jrl_[a-f0-9]{64}$/u),
+        static_layer_id: prefixedDigestSchema("jrl"),
         static_node_id: nodeIdSchema,
     })),
 };
 const reconciliationItemSchema = z.union([
     z.strictObject({
         ...reconciliationItemShape,
-        static_layer_id: z.string().regex(/^jrl_[a-f0-9]{64}$/u),
+        static_layer_id: prefixedDigestSchema("jrl"),
         static_node_id: nodeIdSchema,
         status: z.literal("matched"),
     }),
@@ -171,7 +172,7 @@ const reconciliationItemSchema = z.union([
     }),
 ]);
 const staticLoadStateSchema = z.strictObject({
-    static_layer_id: z.string().regex(/^jrl_[a-f0-9]{64}$/u),
+    static_layer_id: prefixedDigestSchema("jrl"),
     static_node_id: nodeIdSchema,
     kind: z.enum(["javascript-asset", "javascript-chunk", "javascript-module"]),
     status: z.enum([
@@ -191,7 +192,7 @@ const staticLoadStateSchema = z.strictObject({
 });
 /** Deterministic static/passive-runtime reconciliation with a combined JAG. */
 export const javascriptRuntimeReconciliationResultSchema = z.strictObject({
-    reconciliation_id: z.string().regex(/^jrr_[a-f0-9]{64}$/u),
+    reconciliation_id: prefixedDigestSchema("jrr"),
     static_layers: z.array(layerSummarySchema).min(1),
     runtime_captures: z.array(captureSummarySchema).min(1),
     graph: javascriptApplicationGraphSchema,

package/dist/domain/javascriptRuntimeStaticCandidates.js

@@ -1,5 +1,4 @@
-import { posix, relative } from "node:path";
-import { isPathWithinRoot } from "./localPath.js";
+import { posix, relative, win32 } from "node:path";
 import { compareCodePoints, } from "./javascriptApplicationGraph.js";
 /** Index statically reconstructed entities that can receive runtime matches. */
 export const collectStaticRuntimeCandidates = (layers) => layers
@@ -130,12 +129,25 @@ const candidateDigests = (node) => {
     ];
 };
 const pathBelowRoot = (root, value) => {
-    const remainder = relative(root, value);
+    const rootStyle = absoluteFilePathStyle(root);
+    if (rootStyle === null || rootStyle !== absoluteFilePathStyle(value))
+        return null;
+    const remainder = rootStyle === "windows"
+        ? win32.relative(root, value)
+        : relative(root, value);
+    const portableRemainder = remainder.replaceAll("\\", "/");
     if (remainder === "" ||
-        !isPathWithinRoot(root, value) ||
-        remainder.includes("\\"))
+        (rootStyle === "windows" && win32.isAbsolute(remainder)) ||
+        portableRemainder === ".." ||
+        portableRemainder.startsWith("../"))
         return null;
-    return normalizeArtifactPath(remainder);
+    return normalizeArtifactPath(portableRemainder);
+};
+const absoluteFilePathStyle = (path) => {
+    if (/^[a-z]:[\\/]/iu.test(path) ||
+        /^(?:\\\\|\/\/)[^\\/]+[\\/][^\\/]+(?:[\\/]|$)/u.test(path))
+        return "windows";
+    return path.startsWith("/") ? "posix" : null;
 };
 const pathBelowUrlPrefix = (prefix, value) => {
     let base;

package/dist/domain/javascriptSemanticAnalysis.js

@@ -1,6 +1,6 @@
 import * as t from "@babel/types";
 import { failedJavaScriptSemanticIr, } from "./javascriptSemanticIr.js";
-import { collectSemanticModuleLink, collectSemanticCallable, collectSemanticReferences, immutableSemanticBindings, immutableSemanticScopes, semanticModuleOrigin, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
+import { collectSemanticModuleLink, collectSemanticCallable, collectSemanticReferences, immutableSemanticBindings, immutableSemanticScopes, semanticStaticPropertyName, } from "./javascriptSemanticProjection.js";
 import { currentSemanticScope, resolveSemanticBindingFromScope, semanticScopeId, semanticVariableScope, } from "./javascriptSemanticState.js";
 import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { collectSemanticReturns, resolveSemanticModuleCallables, } from "./javascriptSemanticReturns.js";
@@ -19,6 +19,9 @@ export const analyzeJavaScriptSemantics = (source) => {
 export const analyzeParsedJavaScriptSemantics = (file) => {
     const state = createState(file.program);
     collectDefinitions(file.program, state);
+    traverseJavaScriptAst(file.program, {
+        enter: (node) => collectSemanticModuleLink(node, state),
+    });
     const references = collectSemanticReferences(file.program, state);
     const parserPartial = file.errors.length > 0;
     const bindings = immutableSemanticBindings(state);
@@ -71,15 +74,32 @@ const collectDefinitions = (program, state) => {
     const stack = [
         currentSemanticScope(state.scopes),
     ];
-    const openedScopes = new WeakSet();
+    const openedScopes = new WeakMap();
     traverseJavaScriptAst(program, {
         enter: (node, parent) => {
-            const parentScope = currentSemanticScope(stack);
+            let parentScope = currentSemanticScope(stack);
+            if (parent !== null &&
+                t.isWithStatement(parent) &&
+                parent.body === node) {
+                const dynamicScope = {
+                    scopeId: `${semanticScopeId("block", parent)}:with`,
+                    parentScopeId: parentScope.scopeId,
+                    kind: "block",
+                    location: range(parent),
+                    bindingsComplete: false,
+                    bindings: new Map(),
+                };
+                state.scopes.push(dynamicScope);
+                state.scopesById.set(dynamicScope.scopeId, dynamicScope);
+                stack.push(dynamicScope);
+                openedScopes.set(node, 1);
+                parentScope = dynamicScope;
+            }
             bindOuterDeclaration(node, parentScope, state);
             const nested = nestedScope(node, parent, parentScope, state);
             if (nested !== undefined) {
                 stack.push(nested);
-                openedScopes.add(node);
+                openedScopes.set(node, (openedScopes.get(node) ?? 0) + 1);
             }
             const scope = currentSemanticScope(stack);
             state.scopeByNode.set(node, scope);
@@ -91,10 +111,9 @@ const collectDefinitions = (program, state) => {
                 state,
             });
             bindInnerDeclaration(node, parent, scope, state);
-            collectSemanticModuleLink(node, state);
         },
         exit: (node) => {
-            if (openedScopes.has(node))
+            for (let count = openedScopes.get(node) ?? 0; count > 0; count--)
                 stack.pop();
         },
     });
@@ -134,6 +153,16 @@ const bindInnerDeclaration = (node, parent, scope, state) => {
                 ? parent.kind !== "const"
                 : true,
         });
+    else if (t.isClassExpression(node) && t.isIdentifier(node.id))
+        addBinding({
+            state,
+            scope,
+            name: node.id.name,
+            kind: "class",
+            mutable: false,
+            definitionNode: node.id,
+            initializer: node,
+        });
     else if (t.isFunction(node))
         bindFunctionLocals(node, scope, state);
     else if (t.isCatchClause(node) && node.param != null)
@@ -149,14 +178,22 @@ const bindInnerDeclaration = (node, parent, scope, state) => {
         addAssignment(node.left, node.right, scope, state);
 };
 const nestedScope = (node, parent, parentScope, state) => {
+    const switchOwner = t.isSwitchCase(node) && parent !== null && t.isSwitchStatement(parent)
+        ? parent
+        : undefined;
+    if (switchOwner !== undefined) {
+        const existing = state.scopesById.get(semanticScopeId("block", switchOwner));
+        if (existing !== undefined)
+            return existing;
+    }
     const kind = scopeKind(node, parent);
     if (kind === undefined)
         return undefined;
     const scope = {
-        scopeId: semanticScopeId(kind, node),
+        scopeId: semanticScopeId(kind, switchOwner ?? node),
         parentScopeId: parentScope.scopeId,
         kind,
-        location: range(node),
+        location: range(switchOwner ?? node),
         bindingsComplete: true,
         bindings: new Map(),
     };
@@ -171,6 +208,18 @@ const scopeKind = (node, parent) => {
         return "class";
     if (t.isCatchClause(node))
         return "catch";
+    if (t.isForStatement(node) ||
+        t.isForOfStatement(node) ||
+        t.isForInStatement(node))
+        return "block";
+    // A switch body is one lexical scope shared by all its cases, so `let` in
+    // two cases must resolve to one binding rather than collide or leak.
+    if (t.isSwitchCase(node))
+        return "block";
+    // Each `static {}` block is its own lexical scope; otherwise a `let` in two
+    // static blocks would collide in the enclosing class scope.
+    if (t.isStaticBlock(node))
+        return "static-block";
     if (t.isBlockStatement(node) &&
         !(parent !== null && t.isFunction(parent) && parent.body === node))
         return "block";
@@ -225,16 +274,6 @@ const bindPattern = (input) => {
         return;
     }
     if (t.isIdentifier(pattern)) {
-        const baseOrigin = semanticModuleOrigin(initializer, []);
-        const directOrigin = baseOrigin === undefined || projection.includes(null)
-            ? undefined
-            : {
-                ...baseOrigin,
-                importedPath: [
-                    ...baseOrigin.importedPath,
-                    ...projection.map((segment) => String(segment)),
-                ],
-            };
         addBinding({
             state,
             scope,
@@ -243,7 +282,6 @@ const bindPattern = (input) => {
             mutable,
             definitionNode: pattern,
             initializer,
-            ...(directOrigin === undefined ? {} : { directOrigin }),
             projection,
         });
         return;