rea-agents 6.5.0 → 6.7.0

package/dist/cli-runtime/{javascriptApplicationAnalysis-HgMzVMQw.js → javascriptApplicationAnalysis-Dk6yBV8g.js}

@@ -1,166 +1,11 @@
 import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
-import { canonicalJson, canonicalJsonDigestSteps, compareUnicodeCodePoints, digestCanonicalValue, digestSchema, init_artifactGraph, init_canonicalDigest, init_canonicalJsonDigestSteps, init_canonicalOrdering, init_comparisonSemantics, init_digests, init_localPath, init_unicodeCodePointOrder, integrityContradictionSchema, localPathStringSchema, prefixedDigestSchema, uniqueSorted } from "./reconstructionObligationLedgerSchemas-Bao0xMr-.js";
-import { freezeJsonSnapshot, freezeOwnedJsonSnapshotSteps, init_immutableJson, init_jsonValue, jsonValueSchema } from "./errorSchemas-CTRmvMl3.js";
+import { canonicalJson, canonicalJsonDigestSteps, compareUnicodeCodePoints, digestCanonicalValue, digestSchema, init_artifactGraph, init_canonicalDigest, init_canonicalJsonDigestSteps, init_canonicalOrdering, init_comparisonSemantics, init_digests, init_localPath, init_unicodeCodePointOrder, integrityContradictionSchema, localPathStringSchema, prefixedDigestSchema, uniqueSorted } from "./reconstructionObligationLedgerSchemas-Bi6sect1.js";
+import { freezeJsonSnapshot, freezeOwnedJsonSnapshotSteps, init_immutableJson, init_jsonValue, jsonValueSchema } from "./errorSchemas-Ixz_q7qt.js";
 import { z } from "zod";
 import { posix } from "node:path";
 import { domainToASCII, fileURLToPath, pathToFileURL } from "node:url";
 import { TraceMap } from "@jridgewell/trace-mapping";
 
-//#region dist/domain/javascript/javascriptSourceSelection.js
-var javaScriptSourcePathsSchema, javaScriptSourceSelectionSchema;
-function init_javascriptSourceSelection() {
-	return (init_javascriptSourceSelection = __esmMin((() => {
-		javaScriptSourcePathsSchema = z.array(z.string().min(1)).min(1).describe("Exact relevant file paths from the artifact inventory, relative to the application root, analyzed in first-request order before unselected scopes; no globs or implicit dependencies. Omit to analyze all sources.");
-		javaScriptSourceSelectionSchema = z.strictObject({
-			requested_paths: javaScriptSourcePathsSchema,
-			unselected_files: z.number().int().min(0)
-		});
-	})))();
-}
-
-//#endregion
-//#region dist/domain/zodCollectionSteps.js
-/** Elements validated between yields, in the issues and paths a whole-array parse reports. */
-function* parseElementSteps(element, values, path, issues) {
-	const parsed = [];
-	for (const [index, value] of values.entries()) {
-		if (index % 64 === 0) yield;
-		const result = element.safeParse(value);
-		if (result.success) parsed.push(result.data);
-		else issues.push(...result.error.issues.map((issue) => ({
-			...issue,
-			path: [
-				...path,
-				index,
-				...issue.path
-			]
-		})));
-	}
-	return parsed;
-}
-var arrayContainerSchema;
-function init_zodCollectionSteps() {
-	return (init_zodCollectionSteps = __esmMin((() => {
-		arrayContainerSchema = (array) => array.clone({
-			...array.def,
-			element: z.unknown()
-		});
-	})))();
-}
-
-//#endregion
-//#region dist/domain/javascript/javascriptSourceMapPaths.js
-var javascriptSourceMapReferenceSchema, resolveJavaScriptSourceMapReferences, resolveJavaScriptSourceMapUrl, resolveSourceMapUrls, resolveJavaScriptSourceMapPath, unusableHost, carriesUsableHost, windowsFileUrl, decodedUrlPath;
-function init_javascriptSourceMapPaths() {
-	return (init_javascriptSourceMapPaths = __esmMin((() => {
-		javascriptSourceMapReferenceSchema = z.strictObject({
-			source_name: z.string(),
-			source_root: z.string().nullable(),
-			map_path: z.string().min(1),
-			resolution: z.discriminatedUnion("kind", [z.strictObject({
-				kind: z.enum(["artifact-relative", "suffix"]),
-				path: z.string().min(1)
-			}), z.strictObject({
-				kind: z.literal("unresolved"),
-				reason: z.string().min(1)
-			})])
-		});
-		resolveJavaScriptSourceMapReferences = (sourceNames, sourceRoot, mapPath) => {
-			if (sourceNames.length === 0) return [];
-			const resolvedSources = resolveSourceMapUrls(sourceNames.map((sourceName) => sourceName ?? ""), sourceRoot, "");
-			return sourceNames.map((sourceName, index) => {
-				if (sourceName === null) return null;
-				const reference = resolvedSources[index];
-				if (reference === undefined) throw new TypeError(`TraceMap did not resolve source declaration ${String(index)}`);
-				return {
-					source_name: sourceName,
-					source_root: sourceRoot,
-					map_path: mapPath,
-					resolution: resolveJavaScriptSourceMapPath(reference, mapPath)
-				};
-			});
-		};
-		resolveJavaScriptSourceMapUrl = (source, sourceRoot, mapUrl) => {
-			const resolved = resolveSourceMapUrls([source ?? ""], sourceRoot, mapUrl)[0];
-			if (resolved === undefined) throw new TypeError("TraceMap did not resolve its single source declaration");
-			return resolved;
-		};
-		resolveSourceMapUrls = (sources, sourceRoot, mapUrl) => new TraceMap({
-			version: 3,
-			names: [],
-			sources,
-			...sourceRoot == null ? {} : { sourceRoot },
-			mappings: ""
-		}, mapUrl).resolvedSources;
-		resolveJavaScriptSourceMapPath = (source, mapPath) => {
-			const portable = source.replaceAll("\\", "/");
-			const windowsPath = /^[a-z]:\//iu.test(portable) || source.startsWith("\\\\");
-			const anchor = `/${"source/".repeat(portable.split("/").length + 1)}`;
-			const directory = posix.join(anchor, posix.dirname(mapPath));
-			const base = pathToFileURL(`${directory}/`, { windows: false });
-			const absolute = windowsPath ? windowsFileUrl(source) : URL.parse(source);
-			const resolved = windowsPath ? absolute : URL.parse(source, base);
-			if (resolved === null) return {
-				kind: "unresolved",
-				reason: "Source reference is not a valid URL or filesystem path."
-			};
-			if (!resolved.pathname.startsWith("/")) return {
-				kind: "unresolved",
-				reason: "Source reference uses a non-hierarchical URL without a file pathname."
-			};
-			if (resolved.pathname.endsWith("/")) return {
-				kind: "unresolved",
-				reason: "Source reference names a directory rather than a file."
-			};
-			const declaredPath = windowsPath ? absolute?.pathname ?? "" : URL.parse(source, "file:///")?.pathname ?? "";
-			if (/%(?:2f|5c)/iu.test(declaredPath)) return {
-				kind: "unresolved",
-				reason: "Source reference contains an encoded path separator."
-			};
-			const relative = absolute === null ? !portable.startsWith("/") : absolute.href !== resolved.href;
-			const path = decodedUrlPath(resolved);
-			if (path === null) return {
-				kind: "unresolved",
-				reason: "Source reference has malformed URL encoding or an invalid file URL."
-			};
-			const value = relative ? posix.relative(anchor, path) : path.replace(/^\/+/, "");
-			if (value === "" || value === ".." || value.startsWith("../")) return {
-				kind: "unresolved",
-				reason: "Source reference resolves outside the inventoried artifact."
-			};
-			return {
-				path: value,
-				kind: relative ? "artifact-relative" : "suffix"
-			};
-		};
-		unusableHost = /[\0\t\n\r #/:<>?@[\\\]^|%]/u;
-		carriesUsableHost = (host) => !unusableHost.test(host) && domainToASCII(host) !== "";
-		windowsFileUrl = (path) => {
-			if (path.startsWith("\\\\") && !carriesUsableHost(path.slice(2).split("\\")[0] ?? "")) return null;
-			try {
-				return pathToFileURL(path, { windows: true });
-			} catch (cause) {
-				if (cause instanceof TypeError) return null;
-				throw cause;
-			}
-		};
-		decodedUrlPath = (url) => {
-			try {
-				if (url.protocol === "file:") {
-					const windows = url.hostname !== "" && url.hostname !== "localhost";
-					const path = fileURLToPath(url, { windows });
-					return windows ? path.replaceAll("\\", "/") : path;
-				}
-				return `${url.host}${decodeURIComponent(url.pathname)}`;
-			} catch (cause) {
-				if (cause instanceof URIError || cause instanceof TypeError) return null;
-				throw cause;
-			}
-		};
-	})))();
-}
-
-//#endregion
 //#region dist/domain/javascript/javascriptApplicationEvidenceSchemas.js
 var boundedTextSchema$2, boundedKeySchema, unsafePathSegments, isSafeRelativePath, relativePathSchema$1, applicationEvidenceAuthoritySchema, applicationFactStateSchema, applicationConfidenceSchema, applicationUnavailableReasonSchema, unavailableFactSchema, availableArtifactSchema, applicationArtifactReferenceSchema, sourceRangeSchema$1, fileOffsetRangeSchema, applicationLocationSchema, applicationLocationReferenceSchema, applicationExtractorSchema, applicationLimitSchema, coverageLimitsSchema, omittedCountSchema, applicationCoverageSchema, completeApplicationCoverage, partialApplicationCoverage, truncatedApplicationCoverage, applicationGraphEvidenceBaseSchema, applicationGraphEvidenceContextSchema, applicationGraphEvidenceLocationSchema, checkAuthorityState, checkStateConfidence, checkTraceability, checkArtifactBacking, applicationGraphEvidenceSchema, applicationNodeIdentitySchema;
 function init_javascriptApplicationEvidenceSchemas() {
@@ -512,102 +357,546 @@ function init_javascriptApplicationEvidenceSchemas() {
 }
 
 //#endregion
-//#region dist/domain/javascript/javascriptApplicationGraphSchemas.js
-var boundedTextSchema$1, JAVASCRIPT_APPLICATION_NODE_KINDS, applicationNodeKindSchema, JAVASCRIPT_APPLICATION_RELATIONS, applicationRelationSchema, applicationPropertiesSchema, applicationNodeObservationBaseSchema, applicationNodeObservationInputSchema, applicationNodeObservationSchema, applicationNodeInputSchema, applicationNodeSchema, applicationEdgeInputSchema, applicationEdgeSchema, javascriptApplicationGraphInputSchema, javascriptApplicationGraphRecordSchema;
-function init_javascriptApplicationGraphSchemas() {
-	return (init_javascriptApplicationGraphSchemas = __esmMin((() => {
-		init_javascriptSourceMapPaths();
+//#region dist/domain/javascript/javascriptSemanticGraphSchemas.js
+var boundedTextSchema$1, semanticNodeIdSchema, semanticRelationIdSchema, semanticUnknownIdSchema, semanticEvidenceContextIdSchema, javaScriptSemanticEvidenceContextSchema, javaScriptSemanticEvidenceReferenceSchema, JAVASCRIPT_SEMANTIC_NODE_KINDS, JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, JAVASCRIPT_SEMANTIC_RELATIONS, JAVASCRIPT_SEMANTIC_RELATION_FAMILY, relativePathSchema, sourcePointSchema, sourceRangeSchema, semanticPropertiesSchema, semanticNodeIdentitySchema, javaScriptSemanticNodeInputSchema, javaScriptSemanticNodeSchema, javaScriptSemanticRelationInputSchema, javaScriptSemanticRelationSchema, JAVASCRIPT_SEMANTIC_UNKNOWN_REASONS, javaScriptSemanticUnknownOmissionSchema, javaScriptSemanticUnknownOmissionsSchema, javaScriptSemanticUnknownInputSchema, javaScriptSemanticUnknownSchema, fingerprintComponentsSchema, javaScriptSemanticFingerprintInputSchema, javaScriptSemanticFingerprintSchema, familyCoverageSchema, graphCoverageSchema, javaScriptSemanticGraphInputSchema, javaScriptSemanticGraphRecordSchema;
+function init_javascriptSemanticGraphSchemas() {
+	return (init_javascriptSemanticGraphSchemas = __esmMin((() => {
 		init_javascriptApplicationEvidenceSchemas();
 		init_jsonValue();
 		init_digests();
 		boundedTextSchema$1 = z.string().min(1);
-		JAVASCRIPT_APPLICATION_NODE_KINDS = [
-			"package",
-			"installer",
-			"artifact",
-			"asar-entry",
-			"electron-main",
-			"electron-preload",
-			"electron-renderer",
-			"electron-utility",
-			"javascript-asset",
-			"javascript-chunk",
-			"javascript-module",
-			"javascript-expression",
-			"source-map",
-			"source-module",
-			"browser-window",
-			"frame",
-			"target",
-			"context-bridge-api",
-			"ipc-channel",
-			"ipc-handler",
-			"worker",
-			"service-worker",
-			"endpoint",
-			"storage",
-			"native-addon",
-			"native-export",
-			"managed-assembly",
-			"managed-module",
-			"managed-type",
-			"managed-method",
-			"managed-field",
-			"managed-pinvoke-import",
-			"managed-native-implementation",
-			"runtime-script-instance",
-			"unknown"
-		];
-		applicationNodeKindSchema = z.enum(JAVASCRIPT_APPLICATION_NODE_KINDS);
-		JAVASCRIPT_APPLICATION_RELATIONS = [
-			"contains",
-			"loads",
-			"imports",
-			"maps_to",
-			"exposes",
-			"sends",
-			"invokes",
-			"handles",
-			"calls",
-			"persists_to",
-			"observed_as",
-			"changed_from"
-		];
-		applicationRelationSchema = z.enum(JAVASCRIPT_APPLICATION_RELATIONS);
-		applicationPropertiesSchema = z.record(z.string().min(1), jsonValueSchema);
-		applicationNodeObservationBaseSchema = z.strictObject({
-			label: z.string().min(1).nullable(),
-			source_map_reference: javascriptSourceMapReferenceSchema.nullable(),
-			properties: applicationPropertiesSchema,
-			evidence: applicationGraphEvidenceSchema
-		});
-		applicationNodeObservationInputSchema = applicationNodeObservationBaseSchema.extend({ source_map_reference: javascriptSourceMapReferenceSchema.nullable().default(null) });
-		applicationNodeObservationSchema = applicationNodeObservationBaseSchema.extend({
-			observation_id: prefixedDigestSchema("jag_observation"),
-			identifier_strategy: z.strictObject({
-				strategy: z.literal("semantic-content-sha256"),
-				stability: z.literal("observation-exact")
-			})
-		});
-		applicationNodeInputSchema = z.strictObject({
-			kind: applicationNodeKindSchema,
-			identity: applicationNodeIdentitySchema,
-			observations: z.array(applicationNodeObservationInputSchema).min(1)
-		});
-		applicationNodeSchema = z.strictObject({
-			node_id: prefixedDigestSchema("jag_node"),
-			kind: applicationNodeKindSchema,
-			identity: applicationNodeIdentitySchema,
-			observations: z.array(applicationNodeObservationSchema).min(1)
-		});
-		applicationEdgeInputSchema = z.strictObject({
-			source_node_id: prefixedDigestSchema("jag_node"),
-			target_node_id: prefixedDigestSchema("jag_node"),
-			relation: applicationRelationSchema,
-			properties: applicationPropertiesSchema,
-			evidence: applicationGraphEvidenceSchema
+		semanticNodeIdSchema = prefixedDigestSchema("jsrg_node");
+		semanticRelationIdSchema = z.string().regex(/^jsrg_relation_[a-f0-9]{64}$/u);
+		semanticUnknownIdSchema = z.string().regex(/^jsrg_unknown_[a-f0-9]{64}$/u);
+		semanticEvidenceContextIdSchema = z.string().regex(/^jsrg_evidence_[a-f0-9]{64}$/u);
+		javaScriptSemanticEvidenceContextSchema = applicationGraphEvidenceContextSchema.extend({ context_id: semanticEvidenceContextIdSchema });
+		javaScriptSemanticEvidenceReferenceSchema = z.strictObject({
+			context_id: semanticEvidenceContextIdSchema,
+			location: applicationGraphEvidenceLocationSchema
 		});
-		applicationEdgeSchema = applicationEdgeInputSchema.extend({
+		JAVASCRIPT_SEMANTIC_NODE_KINDS = [
+			"module",
+			"function",
+			"parameter",
+			"binding",
+			"expression",
+			"literal",
+			"property-slot",
+			"call-site",
+			"return-site",
+			"closure-capture",
+			"promise",
+			"task",
+			"event",
+			"listener",
+			"timer",
+			"child-process",
+			"stdio",
+			"signal",
+			"config-source",
+			"request",
+			"response",
+			"boundary",
+			"resource",
+			"unknown-frontier"
+		];
+		JAVASCRIPT_SEMANTIC_RELATION_FAMILIES = [
+			"boundary",
+			"call-flow",
+			"child-process",
+			"closure",
+			"configuration",
+			"data-flow",
+			"event",
+			"object-flow",
+			"promise-ownership",
+			"request",
+			"resource-lifecycle",
+			"timer"
+		];
+		JAVASCRIPT_SEMANTIC_RELATIONS = [
+			"acquires",
+			"aggregates",
+			"aliases",
+			"argument-to-parameter",
+			"awaits",
+			"calls",
+			"cancels-timer",
+			"captures",
+			"chains",
+			"coerces",
+			"connects-stdio",
+			"consumed-by",
+			"constructs-request",
+			"creates-promise",
+			"defaults",
+			"defines",
+			"destructures",
+			"detaches-task",
+			"dispatches-candidate",
+			"forwards-signal",
+			"listens-error",
+			"listens-exit",
+			"owns",
+			"overrides",
+			"parses",
+			"reads",
+			"reads-argv",
+			"reads-config",
+			"reads-environment",
+			"reads-property",
+			"registers-listener",
+			"releases",
+			"removes-listener",
+			"returns-task",
+			"returns-to-call",
+			"schedules-timer",
+			"spawns",
+			"spreads",
+			"supplies-argv",
+			"supplies-env",
+			"supplies-request-field",
+			"validates",
+			"writes",
+			"writes-property"
+		];
+		JAVASCRIPT_SEMANTIC_RELATION_FAMILY = {
+			acquires: "resource-lifecycle",
+			aggregates: "promise-ownership",
+			aliases: "data-flow",
+			"argument-to-parameter": "call-flow",
+			awaits: "promise-ownership",
+			calls: "call-flow",
+			"cancels-timer": "timer",
+			captures: "closure",
+			chains: "promise-ownership",
+			coerces: "boundary",
+			"connects-stdio": "child-process",
+			"consumed-by": "request",
+			"constructs-request": "request",
+			"creates-promise": "promise-ownership",
+			defaults: "configuration",
+			defines: "data-flow",
+			destructures: "object-flow",
+			"detaches-task": "promise-ownership",
+			"dispatches-candidate": "event",
+			"forwards-signal": "child-process",
+			"listens-error": "child-process",
+			"listens-exit": "child-process",
+			owns: "promise-ownership",
+			overrides: "configuration",
+			parses: "boundary",
+			reads: "data-flow",
+			"reads-argv": "configuration",
+			"reads-config": "configuration",
+			"reads-environment": "configuration",
+			"reads-property": "object-flow",
+			"registers-listener": "event",
+			releases: "resource-lifecycle",
+			"removes-listener": "event",
+			"returns-task": "promise-ownership",
+			"returns-to-call": "call-flow",
+			"schedules-timer": "timer",
+			spawns: "child-process",
+			spreads: "object-flow",
+			"supplies-argv": "child-process",
+			"supplies-env": "child-process",
+			"supplies-request-field": "request",
+			validates: "boundary",
+			writes: "data-flow",
+			"writes-property": "object-flow"
+		};
+		relativePathSchema = z.string().min(1).refine((path) => !path.startsWith("/") && path.split("/").every((part) => ![
+			"",
+			".",
+			".."
+		].includes(part)), "Expected a normalized relative POSIX path without traversal");
+		sourcePointSchema = z.strictObject({
+			line: z.number().int().min(1),
+			column: z.number().int().min(0)
+		});
+		sourceRangeSchema = z.strictObject({
+			start: sourcePointSchema,
+			end: sourcePointSchema
+		}).superRefine((range, context) => {
+			if (range.end.line < range.start.line || range.end.line === range.start.line && range.end.column < range.start.column) context.addIssue({
+				code: "custom",
+				path: ["end"],
+				message: "Source range end must not precede its start"
+			});
+		});
+		semanticPropertiesSchema = z.record(z.string().min(1), jsonValueSchema);
+		semanticNodeIdentitySchema = z.strictObject({
+			artifact_sha256: digestSchema,
+			module_path: relativePathSchema,
+			source_range: sourceRangeSchema.nullable(),
+			role_key: z.string().min(1)
+		});
+		javaScriptSemanticNodeInputSchema = z.strictObject({
+			kind: z.enum(JAVASCRIPT_SEMANTIC_NODE_KINDS),
+			identity: semanticNodeIdentitySchema,
+			function_node_id: semanticNodeIdSchema.nullable(),
+			application_node_ids: z.array(prefixedDigestSchema("jag_node")),
+			label: z.string().min(1).nullable(),
+			properties: semanticPropertiesSchema,
+			evidence: applicationGraphEvidenceSchema
+		});
+		javaScriptSemanticNodeSchema = javaScriptSemanticNodeInputSchema.extend({
+			evidence: javaScriptSemanticEvidenceReferenceSchema,
+			node_id: semanticNodeIdSchema.describe("SHA-256 of the node kind and identity; stable for one artifact version.")
+		});
+		javaScriptSemanticRelationInputSchema = z.strictObject({
+			source_node_id: semanticNodeIdSchema,
+			target_node_id: semanticNodeIdSchema,
+			relation: z.enum(JAVASCRIPT_SEMANTIC_RELATIONS),
+			resolution: z.enum(["resolved", "candidate"]),
+			properties: semanticPropertiesSchema,
+			evidence: applicationGraphEvidenceSchema
+		});
+		javaScriptSemanticRelationSchema = javaScriptSemanticRelationInputSchema.extend({
+			evidence: javaScriptSemanticEvidenceReferenceSchema,
+			relation_id: semanticRelationIdSchema.describe("SHA-256 of the exact relation content, including its evidence reference.")
+		});
+		JAVASCRIPT_SEMANTIC_UNKNOWN_REASONS = [
+			"ambiguous-target",
+			"bound-reached",
+			"dynamic-call",
+			"dynamic-property",
+			"dynamic-scope",
+			"eval-or-generated-code",
+			"incomplete-module",
+			"missing-source",
+			"resource-limit",
+			"unknown-value",
+			"unsupported-syntax"
+		];
+		javaScriptSemanticUnknownOmissionSchema = z.strictObject({
+			family: z.enum(JAVASCRIPT_SEMANTIC_RELATION_FAMILIES),
+			reason: z.enum(JAVASCRIPT_SEMANTIC_UNKNOWN_REASONS),
+			occurrences: z.number().int().positive()
+		});
+		javaScriptSemanticUnknownOmissionsSchema = z.array(javaScriptSemanticUnknownOmissionSchema).min(1).max(JAVASCRIPT_SEMANTIC_RELATION_FAMILIES.length * JAVASCRIPT_SEMANTIC_UNKNOWN_REASONS.length);
+		javaScriptSemanticUnknownInputSchema = z.strictObject({
+			node_id: semanticNodeIdSchema.nullable(),
+			family: z.enum(JAVASCRIPT_SEMANTIC_RELATION_FAMILIES),
+			relation_kinds: z.array(z.enum(JAVASCRIPT_SEMANTIC_RELATIONS)).min(1),
+			reason: z.enum(JAVASCRIPT_SEMANTIC_UNKNOWN_REASONS),
+			detail: boundedTextSchema$1,
+			candidate_node_ids: z.array(semanticNodeIdSchema),
+			evidence: applicationGraphEvidenceSchema
+		});
+		javaScriptSemanticUnknownSchema = javaScriptSemanticUnknownInputSchema.extend({
+			evidence: javaScriptSemanticEvidenceReferenceSchema,
+			unknown_id: semanticUnknownIdSchema
+		});
+		fingerprintComponentsSchema = z.strictObject({
+			parameter_arity: z.number().int().min(0),
+			normalized_ast_sha256: digestSchema,
+			control_flow_sha256: digestSchema,
+			relation_shape_sha256: digestSchema,
+			literal_set_sha256: digestSchema,
+			effects: z.array(z.enum([
+				"async",
+				"child-process",
+				"event",
+				"network",
+				"promise",
+				"resource",
+				"timer"
+			]))
+		});
+		javaScriptSemanticFingerprintInputSchema = z.strictObject({
+			function_node_id: semanticNodeIdSchema,
+			algorithm: z.literal("rea.javascript-semantic-function"),
+			status: z.enum([
+				"complete",
+				"partial",
+				"unavailable"
+			]),
+			components: fingerprintComponentsSchema,
+			limitations: z.array(boundedTextSchema$1),
+			evidence: applicationGraphEvidenceSchema
+		});
+		javaScriptSemanticFingerprintSchema = javaScriptSemanticFingerprintInputSchema.extend({
+			evidence: javaScriptSemanticEvidenceReferenceSchema,
+			fingerprint_id: prefixedDigestSchema("jsrg_fingerprint"),
+			fingerprint_sha256: digestSchema
+		});
+		familyCoverageSchema = z.strictObject({
+			family: z.enum(JAVASCRIPT_SEMANTIC_RELATION_FAMILIES),
+			status: z.enum([
+				"complete",
+				"partial",
+				"unknown",
+				"unsupported"
+			]),
+			retained_relations: z.number().int().min(0),
+			omitted_relations: z.number().int().min(0).nullable(),
+			unknown_ids: z.array(semanticUnknownIdSchema)
+		});
+		graphCoverageSchema = z.strictObject({
+			status: z.enum([
+				"complete",
+				"partial",
+				"unknown",
+				"unavailable"
+			]),
+			truncated: z.boolean(),
+			omitted_unknown_occurrences: javaScriptSemanticUnknownOmissionsSchema.exactOptional(),
+			omitted_nodes: z.number().int().min(0).nullable(),
+			omitted_relations: z.number().int().min(0).nullable(),
+			limits: z.array(z.strictObject({
+				name: z.string().min(1),
+				value: z.number().int().min(0),
+				unit: z.enum([
+					"items",
+					"bytes",
+					"milliseconds",
+					"depth",
+					"other"
+				])
+			})),
+			families: z.array(familyCoverageSchema).length(12)
+		});
+		javaScriptSemanticGraphInputSchema = z.strictObject({
+			schema: z.literal("JavaScriptSemanticRelationGraph"),
+			root_artifact_sha256: digestSchema,
+			application_graph_id: prefixedDigestSchema("jag"),
+			root_node_ids: z.array(semanticNodeIdSchema).min(1),
+			evidence_contexts: z.array(javaScriptSemanticEvidenceContextSchema),
+			nodes: z.array(javaScriptSemanticNodeSchema).min(1),
+			relations: z.array(javaScriptSemanticRelationSchema),
+			fingerprints: z.array(javaScriptSemanticFingerprintSchema),
+			unknowns: z.array(javaScriptSemanticUnknownSchema),
+			coverage: graphCoverageSchema,
+			limitations: z.array(boundedTextSchema$1)
+		});
+		javaScriptSemanticGraphRecordSchema = javaScriptSemanticGraphInputSchema.extend({ graph_id: prefixedDigestSchema("jsrg") });
+	})))();
+}
+
+//#endregion
+//#region dist/domain/javascript/javascriptSourceSelection.js
+var javaScriptSourcePathsSchema, javaScriptSourceSelectionSchema;
+function init_javascriptSourceSelection() {
+	return (init_javascriptSourceSelection = __esmMin((() => {
+		javaScriptSourcePathsSchema = z.array(z.string().min(1)).min(1).describe("Exact relevant file paths from the artifact inventory, relative to the application root, analyzed in first-request order before unselected scopes; no globs or implicit dependencies. Omit to analyze all sources.");
+		javaScriptSourceSelectionSchema = z.strictObject({
+			requested_paths: javaScriptSourcePathsSchema,
+			unselected_files: z.number().int().min(0)
+		});
+	})))();
+}
+
+//#endregion
+//#region dist/domain/javascript/javascriptSourceMapPaths.js
+var javascriptSourceMapReferenceSchema, resolveJavaScriptSourceMapReferences, resolveJavaScriptSourceMapUrl, resolveSourceMapUrls, resolveJavaScriptSourceMapPath, unusableHost, carriesUsableHost, windowsFileUrl, decodedUrlPath;
+function init_javascriptSourceMapPaths() {
+	return (init_javascriptSourceMapPaths = __esmMin((() => {
+		javascriptSourceMapReferenceSchema = z.strictObject({
+			source_name: z.string(),
+			source_root: z.string().nullable(),
+			map_path: z.string().min(1),
+			resolution: z.discriminatedUnion("kind", [z.strictObject({
+				kind: z.enum(["artifact-relative", "suffix"]),
+				path: z.string().min(1)
+			}), z.strictObject({
+				kind: z.literal("unresolved"),
+				reason: z.string().min(1)
+			})])
+		});
+		resolveJavaScriptSourceMapReferences = (sourceNames, sourceRoot, mapPath) => {
+			if (sourceNames.length === 0) return [];
+			const resolvedSources = resolveSourceMapUrls(sourceNames.map((sourceName) => sourceName ?? ""), sourceRoot, "");
+			return sourceNames.map((sourceName, index) => {
+				if (sourceName === null) return null;
+				const reference = resolvedSources[index];
+				if (reference === undefined) throw new TypeError(`TraceMap did not resolve source declaration ${String(index)}`);
+				return {
+					source_name: sourceName,
+					source_root: sourceRoot,
+					map_path: mapPath,
+					resolution: resolveJavaScriptSourceMapPath(reference, mapPath)
+				};
+			});
+		};
+		resolveJavaScriptSourceMapUrl = (source, sourceRoot, mapUrl) => {
+			const resolved = resolveSourceMapUrls([source ?? ""], sourceRoot, mapUrl)[0];
+			if (resolved === undefined) throw new TypeError("TraceMap did not resolve its single source declaration");
+			return resolved;
+		};
+		resolveSourceMapUrls = (sources, sourceRoot, mapUrl) => new TraceMap({
+			version: 3,
+			names: [],
+			sources,
+			...sourceRoot == null ? {} : { sourceRoot },
+			mappings: ""
+		}, mapUrl).resolvedSources;
+		resolveJavaScriptSourceMapPath = (source, mapPath) => {
+			const portable = source.replaceAll("\\", "/");
+			const windowsPath = /^[a-z]:\//iu.test(portable) || source.startsWith("\\\\");
+			const anchor = `/${"source/".repeat(portable.split("/").length + 1)}`;
+			const directory = posix.join(anchor, posix.dirname(mapPath));
+			const base = pathToFileURL(`${directory}/`, { windows: false });
+			const absolute = windowsPath ? windowsFileUrl(source) : URL.parse(source);
+			const resolved = windowsPath ? absolute : URL.parse(source, base);
+			if (resolved === null) return {
+				kind: "unresolved",
+				reason: "Source reference is not a valid URL or filesystem path."
+			};
+			if (!resolved.pathname.startsWith("/")) return {
+				kind: "unresolved",
+				reason: "Source reference uses a non-hierarchical URL without a file pathname."
+			};
+			if (resolved.pathname.endsWith("/")) return {
+				kind: "unresolved",
+				reason: "Source reference names a directory rather than a file."
+			};
+			const declaredPath = windowsPath ? absolute?.pathname ?? "" : URL.parse(source, "file:///")?.pathname ?? "";
+			if (/%(?:2f|5c)/iu.test(declaredPath)) return {
+				kind: "unresolved",
+				reason: "Source reference contains an encoded path separator."
+			};
+			const relative = absolute === null ? !portable.startsWith("/") : absolute.href !== resolved.href;
+			const path = decodedUrlPath(resolved);
+			if (path === null) return {
+				kind: "unresolved",
+				reason: "Source reference has malformed URL encoding or an invalid file URL."
+			};
+			const value = relative ? posix.relative(anchor, path) : path.replace(/^\/+/, "");
+			if (value === "" || value === ".." || value.startsWith("../")) return {
+				kind: "unresolved",
+				reason: "Source reference resolves outside the inventoried artifact."
+			};
+			return {
+				path: value,
+				kind: relative ? "artifact-relative" : "suffix"
+			};
+		};
+		unusableHost = /[\0\t\n\r #/:<>?@[\\\]^|%]/u;
+		carriesUsableHost = (host) => !unusableHost.test(host) && domainToASCII(host) !== "";
+		windowsFileUrl = (path) => {
+			if (path.startsWith("\\\\") && !carriesUsableHost(path.slice(2).split("\\")[0] ?? "")) return null;
+			try {
+				return pathToFileURL(path, { windows: true });
+			} catch (cause) {
+				if (cause instanceof TypeError) return null;
+				throw cause;
+			}
+		};
+		decodedUrlPath = (url) => {
+			try {
+				if (url.protocol === "file:") {
+					const windows = url.hostname !== "" && url.hostname !== "localhost";
+					const path = fileURLToPath(url, { windows });
+					return windows ? path.replaceAll("\\", "/") : path;
+				}
+				return `${url.host}${decodeURIComponent(url.pathname)}`;
+			} catch (cause) {
+				if (cause instanceof URIError || cause instanceof TypeError) return null;
+				throw cause;
+			}
+		};
+	})))();
+}
+
+//#endregion
+//#region dist/domain/javascript/javascriptApplicationGraphSchemas.js
+var boundedTextSchema, JAVASCRIPT_APPLICATION_NODE_KINDS, applicationNodeKindSchema, JAVASCRIPT_APPLICATION_RELATIONS, applicationRelationSchema, applicationPropertiesSchema, applicationNodeObservationBaseSchema, applicationNodeObservationInputSchema, applicationNodeObservationSchema, applicationNodeInputSchema, applicationNodeSchema, applicationEdgeInputSchema, applicationEdgeSchema, javascriptApplicationGraphInputSchema, javascriptApplicationGraphRecordSchema;
+function init_javascriptApplicationGraphSchemas() {
+	return (init_javascriptApplicationGraphSchemas = __esmMin((() => {
+		init_javascriptSourceMapPaths();
+		init_javascriptApplicationEvidenceSchemas();
+		init_jsonValue();
+		init_digests();
+		boundedTextSchema = z.string().min(1);
+		JAVASCRIPT_APPLICATION_NODE_KINDS = [
+			"package",
+			"installer",
+			"artifact",
+			"asar-entry",
+			"electron-main",
+			"electron-preload",
+			"electron-renderer",
+			"electron-utility",
+			"javascript-asset",
+			"javascript-chunk",
+			"javascript-module",
+			"javascript-expression",
+			"source-map",
+			"source-module",
+			"browser-window",
+			"frame",
+			"target",
+			"context-bridge-api",
+			"ipc-channel",
+			"ipc-handler",
+			"worker",
+			"service-worker",
+			"endpoint",
+			"storage",
+			"native-addon",
+			"native-export",
+			"managed-assembly",
+			"managed-module",
+			"managed-type",
+			"managed-method",
+			"managed-field",
+			"managed-pinvoke-import",
+			"managed-native-implementation",
+			"runtime-script-instance",
+			"unknown"
+		];
+		applicationNodeKindSchema = z.enum(JAVASCRIPT_APPLICATION_NODE_KINDS);
+		JAVASCRIPT_APPLICATION_RELATIONS = [
+			"contains",
+			"loads",
+			"imports",
+			"maps_to",
+			"exposes",
+			"sends",
+			"invokes",
+			"handles",
+			"calls",
+			"persists_to",
+			"observed_as",
+			"changed_from"
+		];
+		applicationRelationSchema = z.enum(JAVASCRIPT_APPLICATION_RELATIONS);
+		applicationPropertiesSchema = z.record(z.string().min(1), jsonValueSchema);
+		applicationNodeObservationBaseSchema = z.strictObject({
+			label: z.string().min(1).nullable(),
+			source_map_reference: javascriptSourceMapReferenceSchema.nullable(),
+			properties: applicationPropertiesSchema,
+			evidence: applicationGraphEvidenceSchema
+		});
+		applicationNodeObservationInputSchema = applicationNodeObservationBaseSchema.extend({ source_map_reference: javascriptSourceMapReferenceSchema.nullable().default(null) });
+		applicationNodeObservationSchema = applicationNodeObservationBaseSchema.extend({
+			observation_id: prefixedDigestSchema("jag_observation"),
+			identifier_strategy: z.strictObject({
+				strategy: z.literal("semantic-content-sha256"),
+				stability: z.literal("observation-exact")
+			})
+		});
+		applicationNodeInputSchema = z.strictObject({
+			kind: applicationNodeKindSchema,
+			identity: applicationNodeIdentitySchema,
+			observations: z.array(applicationNodeObservationInputSchema).min(1)
+		});
+		applicationNodeSchema = z.strictObject({
+			node_id: prefixedDigestSchema("jag_node"),
+			kind: applicationNodeKindSchema,
+			identity: applicationNodeIdentitySchema,
+			observations: z.array(applicationNodeObservationSchema).min(1)
+		});
+		applicationEdgeInputSchema = z.strictObject({
+			source_node_id: prefixedDigestSchema("jag_node"),
+			target_node_id: prefixedDigestSchema("jag_node"),
+			relation: applicationRelationSchema,
+			properties: applicationPropertiesSchema,
+			evidence: applicationGraphEvidenceSchema
+		});
+		applicationEdgeSchema = applicationEdgeInputSchema.extend({
 			edge_id: prefixedDigestSchema("jag_edge"),
 			identifier_strategy: z.strictObject({
 				strategy: z.literal("semantic-content-sha256"),
@@ -620,12 +909,42 @@ function init_javascriptApplicationGraphSchemas() {
 			nodes: z.array(applicationNodeSchema).min(1),
 			edges: z.array(applicationEdgeSchema),
 			coverage: applicationCoverageSchema,
-			limitations: z.array(boundedTextSchema$1)
+			limitations: z.array(boundedTextSchema)
 		});
 		javascriptApplicationGraphRecordSchema = javascriptApplicationGraphInputSchema.extend({ graph_id: prefixedDigestSchema("jag") });
 	})))();
 }
 
+//#endregion
+//#region dist/domain/zodCollectionSteps.js
+/** Elements validated between yields, in the issues and paths a whole-array parse reports. */
+function* parseElementSteps(element, values, path, issues) {
+	const parsed = [];
+	for (const [index, value] of values.entries()) {
+		if (index % 64 === 0) yield;
+		const result = element.safeParse(value);
+		if (result.success) parsed.push(result.data);
+		else issues.push(...result.error.issues.map((issue) => ({
+			...issue,
+			path: [
+				...path,
+				index,
+				...issue.path
+			]
+		})));
+	}
+	return parsed;
+}
+var arrayContainerSchema;
+function init_zodCollectionSteps() {
+	return (init_zodCollectionSteps = __esmMin((() => {
+		arrayContainerSchema = (array) => array.clone({
+			...array.def,
+			element: z.unknown()
+		});
+	})))();
+}
+
 //#endregion
 //#region dist/domain/javascript/javascriptApplicationGraph.js
 function* checkGraphContentSteps$1(graph, context) {
@@ -865,429 +1184,124 @@ function init_javascriptApplicationGraph() {
 						"observations",
 						observationIndex,
 						"source_map_reference"
-					]
-				});
-				checkEvidenceNormalization(observation.evidence, [
-					"nodes",
-					index,
-					"observations",
-					observationIndex,
-					"evidence"
-				], context);
-			}
-			if (!node.observations.some((observation) => observationMatchesIdentity(node, observation))) context.addIssue({
-				code: "custom",
-				message: "Node identity is not supported by a compatible observation",
-				path: [
-					"nodes",
-					index,
-					"identity"
-				]
-			});
-		};
-		checkGraphContent$1 = (graph, context) => {
-			const steps = checkGraphContentSteps$1(graph, context);
-			while (steps.next().done !== true);
-		};
-		checkGraphInvariants = (graph, context) => {
-			checkGraphContent$1(graph, context);
-			const { graph_id: identifier, ...semantic } = graph;
-			if (identifier !== `jag_${digestCanonicalValue(semantic, "JavaScript Application Graph")}`) context.addIssue({
-				code: "custom",
-				message: "Graph identifier does not match its semantic content",
-				path: ["graph_id"]
-			});
-		};
-		javascriptApplicationGraphSchema = javascriptApplicationGraphRecordSchema.superRefine(checkGraphInvariants);
-		javascriptApplicationGraphContentSchema = javascriptApplicationGraphInputSchema.superRefine(checkGraphContent$1);
-		createJavaScriptApplicationNode = (input) => {
-			const parsed = applicationNodeInputSchema.parse(input);
-			for (const observation of parsed.observations) freezeJsonSnapshot(observation.properties);
-			const identity = normalizeIdentity(parsed.identity);
-			const identifier = nodeId({
-				kind: parsed.kind,
-				identity
-			});
-			const observations = parsed.observations.map((observation) => {
-				const semantic = {
-					...observation,
-					evidence: normalizeEvidence$1(observation.evidence),
-					identifier_strategy: OBSERVATION_IDENTIFIER_STRATEGY
-				};
-				return applicationNodeObservationSchema.parse({
-					...semantic,
-					observation_id: observationId(identifier, semantic)
-				});
-			}).sort((left, right) => compareUnicodeCodePoints(left.observation_id, right.observation_id));
-			return applicationNodeSchema.parse({
-				node_id: identifier,
-				kind: parsed.kind,
-				identity,
-				observations
-			});
-		};
-		createJavaScriptApplicationEdge = (input) => {
-			const parsed = applicationEdgeInputSchema.parse(input);
-			freezeJsonSnapshot(parsed.properties);
-			const semantic = {
-				...parsed,
-				evidence: normalizeEvidence$1(parsed.evidence),
-				identifier_strategy: EDGE_IDENTIFIER_STRATEGY
-			};
-			return applicationEdgeSchema.parse({
-				...semantic,
-				edge_id: edgeId(semantic)
-			});
-		};
-		createJavaScriptApplicationGraph = (input) => {
-			const semantic = normalizeGraphInput$1(javascriptApplicationGraphInputSchema.parse(input));
-			const content = javascriptApplicationGraphContentSchema.parse(semantic);
-			return {
-				...content,
-				graph_id: `jag_${digestCanonicalValue(content, "JavaScript Application Graph")}`
-			};
-		};
-		normalizeGraphInput$1 = (parsed) => ({
-			...parsed,
-			root_node_ids: uniqueSorted(parsed.root_node_ids),
-			nodes: [...parsed.nodes].sort((left, right) => compareUnicodeCodePoints(left.node_id, right.node_id)),
-			edges: [...parsed.edges].sort((left, right) => compareUnicodeCodePoints(left.edge_id, right.edge_id)),
-			coverage: {
-				...parsed.coverage,
-				limits: normalizeLimits(parsed.coverage.limits)
-			},
-			limitations: uniqueSorted(parsed.limitations)
-		});
-		validatedImmutableApplicationGraphs = new WeakSet();
-		createImmutableJavaScriptApplicationGraphSteps = (input) => sealValidatedApplicationGraphSteps(createJavaScriptApplicationGraph(input));
-		applicationGraphShape = javascriptApplicationGraphInputSchema.shape;
-		applicationGraphContainerSchema = javascriptApplicationGraphInputSchema.extend({
-			nodes: arrayContainerSchema(applicationGraphShape.nodes),
-			edges: arrayContainerSchema(applicationGraphShape.edges)
-		});
-		sealTransferredJavaScriptApplicationGraphSteps = (input) => parseAndSealApplicationGraphSteps(applicationGraphContainerSchema.parse(input));
-		isValidatedImmutableJavaScriptApplicationGraph = (value) => typeof value === "object" && value !== null && validatedImmutableApplicationGraphs.has(value);
-		parseJavaScriptApplicationGraph = (input) => javascriptApplicationGraphSchema.parse(input);
-		computeJavaScriptApplicationGraphSha256 = (input) => digestCanonicalValue(parseJavaScriptApplicationGraph(input), "JavaScript Application Graph");
-		serializeJavaScriptApplicationGraph = (input) => canonicalJson(parseJavaScriptApplicationGraph(input), "JavaScript Application Graph");
-	})))();
-}
-
-//#endregion
-//#region dist/domain/javascript/javascriptSemanticGraphSchemas.js
-var boundedTextSchema, semanticNodeIdSchema, semanticRelationIdSchema, semanticUnknownIdSchema, semanticEvidenceContextIdSchema, javaScriptSemanticEvidenceContextSchema, javaScriptSemanticEvidenceReferenceSchema, JAVASCRIPT_SEMANTIC_NODE_KINDS, JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, JAVASCRIPT_SEMANTIC_RELATIONS, JAVASCRIPT_SEMANTIC_RELATION_FAMILY, relativePathSchema, sourcePointSchema, sourceRangeSchema, semanticPropertiesSchema, semanticNodeIdentitySchema, javaScriptSemanticNodeInputSchema, javaScriptSemanticNodeSchema, javaScriptSemanticRelationInputSchema, javaScriptSemanticRelationSchema, JAVASCRIPT_SEMANTIC_UNKNOWN_REASONS, javaScriptSemanticUnknownInputSchema, javaScriptSemanticUnknownSchema, fingerprintComponentsSchema, javaScriptSemanticFingerprintInputSchema, javaScriptSemanticFingerprintSchema, familyCoverageSchema, graphCoverageSchema, javaScriptSemanticGraphInputSchema, javaScriptSemanticGraphRecordSchema;
-function init_javascriptSemanticGraphSchemas() {
-	return (init_javascriptSemanticGraphSchemas = __esmMin((() => {
-		init_javascriptApplicationEvidenceSchemas();
-		init_jsonValue();
-		init_digests();
-		boundedTextSchema = z.string().min(1);
-		semanticNodeIdSchema = prefixedDigestSchema("jsrg_node");
-		semanticRelationIdSchema = z.string().regex(/^jsrg_relation_[a-f0-9]{64}$/u);
-		semanticUnknownIdSchema = z.string().regex(/^jsrg_unknown_[a-f0-9]{64}$/u);
-		semanticEvidenceContextIdSchema = z.string().regex(/^jsrg_evidence_[a-f0-9]{64}$/u);
-		javaScriptSemanticEvidenceContextSchema = applicationGraphEvidenceContextSchema.extend({ context_id: semanticEvidenceContextIdSchema });
-		javaScriptSemanticEvidenceReferenceSchema = z.strictObject({
-			context_id: semanticEvidenceContextIdSchema,
-			location: applicationGraphEvidenceLocationSchema
-		});
-		JAVASCRIPT_SEMANTIC_NODE_KINDS = [
-			"module",
-			"function",
-			"parameter",
-			"binding",
-			"expression",
-			"literal",
-			"property-slot",
-			"call-site",
-			"return-site",
-			"closure-capture",
-			"promise",
-			"task",
-			"event",
-			"listener",
-			"timer",
-			"child-process",
-			"stdio",
-			"signal",
-			"config-source",
-			"request",
-			"response",
-			"boundary",
-			"resource",
-			"unknown-frontier"
-		];
-		JAVASCRIPT_SEMANTIC_RELATION_FAMILIES = [
-			"boundary",
-			"call-flow",
-			"child-process",
-			"closure",
-			"configuration",
-			"data-flow",
-			"event",
-			"object-flow",
-			"promise-ownership",
-			"request",
-			"resource-lifecycle",
-			"timer"
-		];
-		JAVASCRIPT_SEMANTIC_RELATIONS = [
-			"acquires",
-			"aggregates",
-			"aliases",
-			"argument-to-parameter",
-			"awaits",
-			"calls",
-			"cancels-timer",
-			"captures",
-			"chains",
-			"coerces",
-			"connects-stdio",
-			"consumed-by",
-			"constructs-request",
-			"creates-promise",
-			"defaults",
-			"defines",
-			"destructures",
-			"detaches-task",
-			"dispatches-candidate",
-			"forwards-signal",
-			"listens-error",
-			"listens-exit",
-			"owns",
-			"overrides",
-			"parses",
-			"reads",
-			"reads-argv",
-			"reads-config",
-			"reads-environment",
-			"reads-property",
-			"registers-listener",
-			"releases",
-			"removes-listener",
-			"returns-task",
-			"returns-to-call",
-			"schedules-timer",
-			"spawns",
-			"spreads",
-			"supplies-argv",
-			"supplies-env",
-			"supplies-request-field",
-			"validates",
-			"writes",
-			"writes-property"
-		];
-		JAVASCRIPT_SEMANTIC_RELATION_FAMILY = {
-			acquires: "resource-lifecycle",
-			aggregates: "promise-ownership",
-			aliases: "data-flow",
-			"argument-to-parameter": "call-flow",
-			awaits: "promise-ownership",
-			calls: "call-flow",
-			"cancels-timer": "timer",
-			captures: "closure",
-			chains: "promise-ownership",
-			coerces: "boundary",
-			"connects-stdio": "child-process",
-			"consumed-by": "request",
-			"constructs-request": "request",
-			"creates-promise": "promise-ownership",
-			defaults: "configuration",
-			defines: "data-flow",
-			destructures: "object-flow",
-			"detaches-task": "promise-ownership",
-			"dispatches-candidate": "event",
-			"forwards-signal": "child-process",
-			"listens-error": "child-process",
-			"listens-exit": "child-process",
-			owns: "promise-ownership",
-			overrides: "configuration",
-			parses: "boundary",
-			reads: "data-flow",
-			"reads-argv": "configuration",
-			"reads-config": "configuration",
-			"reads-environment": "configuration",
-			"reads-property": "object-flow",
-			"registers-listener": "event",
-			releases: "resource-lifecycle",
-			"removes-listener": "event",
-			"returns-task": "promise-ownership",
-			"returns-to-call": "call-flow",
-			"schedules-timer": "timer",
-			spawns: "child-process",
-			spreads: "object-flow",
-			"supplies-argv": "child-process",
-			"supplies-env": "child-process",
-			"supplies-request-field": "request",
-			validates: "boundary",
-			writes: "data-flow",
-			"writes-property": "object-flow"
+					]
+				});
+				checkEvidenceNormalization(observation.evidence, [
+					"nodes",
+					index,
+					"observations",
+					observationIndex,
+					"evidence"
+				], context);
+			}
+			if (!node.observations.some((observation) => observationMatchesIdentity(node, observation))) context.addIssue({
+				code: "custom",
+				message: "Node identity is not supported by a compatible observation",
+				path: [
+					"nodes",
+					index,
+					"identity"
+				]
+			});
 		};
-		relativePathSchema = z.string().min(1).refine((path) => !path.startsWith("/") && path.split("/").every((part) => ![
-			"",
-			".",
-			".."
-		].includes(part)), "Expected a normalized relative POSIX path without traversal");
-		sourcePointSchema = z.strictObject({
-			line: z.number().int().min(1),
-			column: z.number().int().min(0)
-		});
-		sourceRangeSchema = z.strictObject({
-			start: sourcePointSchema,
-			end: sourcePointSchema
-		}).superRefine((range, context) => {
-			if (range.end.line < range.start.line || range.end.line === range.start.line && range.end.column < range.start.column) context.addIssue({
+		checkGraphContent$1 = (graph, context) => {
+			const steps = checkGraphContentSteps$1(graph, context);
+			while (steps.next().done !== true);
+		};
+		checkGraphInvariants = (graph, context) => {
+			checkGraphContent$1(graph, context);
+			const { graph_id: identifier, ...semantic } = graph;
+			if (identifier !== `jag_${digestCanonicalValue(semantic, "JavaScript Application Graph")}`) context.addIssue({
 				code: "custom",
-				path: ["end"],
-				message: "Source range end must not precede its start"
+				message: "Graph identifier does not match its semantic content",
+				path: ["graph_id"]
 			});
+		};
+		javascriptApplicationGraphSchema = javascriptApplicationGraphRecordSchema.superRefine(checkGraphInvariants);
+		javascriptApplicationGraphContentSchema = javascriptApplicationGraphInputSchema.superRefine(checkGraphContent$1);
+		createJavaScriptApplicationNode = (input) => {
+			const parsed = applicationNodeInputSchema.parse(input);
+			for (const observation of parsed.observations) freezeJsonSnapshot(observation.properties);
+			const identity = normalizeIdentity(parsed.identity);
+			const identifier = nodeId({
+				kind: parsed.kind,
+				identity
+			});
+			const observations = parsed.observations.map((observation) => {
+				const semantic = {
+					...observation,
+					evidence: normalizeEvidence$1(observation.evidence),
+					identifier_strategy: OBSERVATION_IDENTIFIER_STRATEGY
+				};
+				return applicationNodeObservationSchema.parse({
+					...semantic,
+					observation_id: observationId(identifier, semantic)
+				});
+			}).sort((left, right) => compareUnicodeCodePoints(left.observation_id, right.observation_id));
+			return applicationNodeSchema.parse({
+				node_id: identifier,
+				kind: parsed.kind,
+				identity,
+				observations
+			});
+		};
+		createJavaScriptApplicationEdge = (input) => {
+			const parsed = applicationEdgeInputSchema.parse(input);
+			freezeJsonSnapshot(parsed.properties);
+			const semantic = {
+				...parsed,
+				evidence: normalizeEvidence$1(parsed.evidence),
+				identifier_strategy: EDGE_IDENTIFIER_STRATEGY
+			};
+			return applicationEdgeSchema.parse({
+				...semantic,
+				edge_id: edgeId(semantic)
+			});
+		};
+		createJavaScriptApplicationGraph = (input) => {
+			const semantic = normalizeGraphInput$1(javascriptApplicationGraphInputSchema.parse(input));
+			const content = javascriptApplicationGraphContentSchema.parse(semantic);
+			return {
+				...content,
+				graph_id: `jag_${digestCanonicalValue(content, "JavaScript Application Graph")}`
+			};
+		};
+		normalizeGraphInput$1 = (parsed) => ({
+			...parsed,
+			root_node_ids: uniqueSorted(parsed.root_node_ids),
+			nodes: [...parsed.nodes].sort((left, right) => compareUnicodeCodePoints(left.node_id, right.node_id)),
+			edges: [...parsed.edges].sort((left, right) => compareUnicodeCodePoints(left.edge_id, right.edge_id)),
+			coverage: {
+				...parsed.coverage,
+				limits: normalizeLimits(parsed.coverage.limits)
+			},
+			limitations: uniqueSorted(parsed.limitations)
 		});
-		semanticPropertiesSchema = z.record(z.string().min(1), jsonValueSchema);
-		semanticNodeIdentitySchema = z.strictObject({
-			artifact_sha256: digestSchema,
-			module_path: relativePathSchema,
-			source_range: sourceRangeSchema.nullable(),
-			role_key: z.string().min(1)
-		});
-		javaScriptSemanticNodeInputSchema = z.strictObject({
-			kind: z.enum(JAVASCRIPT_SEMANTIC_NODE_KINDS),
-			identity: semanticNodeIdentitySchema,
-			function_node_id: semanticNodeIdSchema.nullable(),
-			application_node_ids: z.array(prefixedDigestSchema("jag_node")),
-			label: z.string().min(1).nullable(),
-			properties: semanticPropertiesSchema,
-			evidence: applicationGraphEvidenceSchema
-		});
-		javaScriptSemanticNodeSchema = javaScriptSemanticNodeInputSchema.extend({
-			evidence: javaScriptSemanticEvidenceReferenceSchema,
-			node_id: semanticNodeIdSchema.describe("SHA-256 of the node kind and identity; stable for one artifact version.")
-		});
-		javaScriptSemanticRelationInputSchema = z.strictObject({
-			source_node_id: semanticNodeIdSchema,
-			target_node_id: semanticNodeIdSchema,
-			relation: z.enum(JAVASCRIPT_SEMANTIC_RELATIONS),
-			resolution: z.enum(["resolved", "candidate"]),
-			properties: semanticPropertiesSchema,
-			evidence: applicationGraphEvidenceSchema
-		});
-		javaScriptSemanticRelationSchema = javaScriptSemanticRelationInputSchema.extend({
-			evidence: javaScriptSemanticEvidenceReferenceSchema,
-			relation_id: semanticRelationIdSchema.describe("SHA-256 of the exact relation content, including its evidence reference.")
-		});
-		JAVASCRIPT_SEMANTIC_UNKNOWN_REASONS = [
-			"ambiguous-target",
-			"bound-reached",
-			"dynamic-call",
-			"dynamic-property",
-			"dynamic-scope",
-			"eval-or-generated-code",
-			"incomplete-module",
-			"missing-source",
-			"resource-limit",
-			"unknown-value",
-			"unsupported-syntax"
-		];
-		javaScriptSemanticUnknownInputSchema = z.strictObject({
-			node_id: semanticNodeIdSchema.nullable(),
-			family: z.enum(JAVASCRIPT_SEMANTIC_RELATION_FAMILIES),
-			relation_kinds: z.array(z.enum(JAVASCRIPT_SEMANTIC_RELATIONS)).min(1),
-			reason: z.enum(JAVASCRIPT_SEMANTIC_UNKNOWN_REASONS),
-			detail: boundedTextSchema,
-			candidate_node_ids: z.array(semanticNodeIdSchema),
-			evidence: applicationGraphEvidenceSchema
-		});
-		javaScriptSemanticUnknownSchema = javaScriptSemanticUnknownInputSchema.extend({
-			evidence: javaScriptSemanticEvidenceReferenceSchema,
-			unknown_id: semanticUnknownIdSchema
-		});
-		fingerprintComponentsSchema = z.strictObject({
-			parameter_arity: z.number().int().min(0),
-			normalized_ast_sha256: digestSchema,
-			control_flow_sha256: digestSchema,
-			relation_shape_sha256: digestSchema,
-			literal_set_sha256: digestSchema,
-			effects: z.array(z.enum([
-				"async",
-				"child-process",
-				"event",
-				"network",
-				"promise",
-				"resource",
-				"timer"
-			]))
-		});
-		javaScriptSemanticFingerprintInputSchema = z.strictObject({
-			function_node_id: semanticNodeIdSchema,
-			algorithm: z.literal("rea.javascript-semantic-function"),
-			status: z.enum([
-				"complete",
-				"partial",
-				"unavailable"
-			]),
-			components: fingerprintComponentsSchema,
-			limitations: z.array(boundedTextSchema),
-			evidence: applicationGraphEvidenceSchema
-		});
-		javaScriptSemanticFingerprintSchema = javaScriptSemanticFingerprintInputSchema.extend({
-			evidence: javaScriptSemanticEvidenceReferenceSchema,
-			fingerprint_id: prefixedDigestSchema("jsrg_fingerprint"),
-			fingerprint_sha256: digestSchema
-		});
-		familyCoverageSchema = z.strictObject({
-			family: z.enum(JAVASCRIPT_SEMANTIC_RELATION_FAMILIES),
-			status: z.enum([
-				"complete",
-				"partial",
-				"unknown",
-				"unsupported"
-			]),
-			retained_relations: z.number().int().min(0),
-			omitted_relations: z.number().int().min(0).nullable(),
-			unknown_ids: z.array(semanticUnknownIdSchema)
-		});
-		graphCoverageSchema = z.strictObject({
-			status: z.enum([
-				"complete",
-				"partial",
-				"unknown",
-				"unavailable"
-			]),
-			truncated: z.boolean(),
-			omitted_nodes: z.number().int().min(0).nullable(),
-			omitted_relations: z.number().int().min(0).nullable(),
-			limits: z.array(z.strictObject({
-				name: z.string().min(1),
-				value: z.number().int().min(0),
-				unit: z.enum([
-					"items",
-					"bytes",
-					"milliseconds",
-					"depth",
-					"other"
-				])
-			})),
-			families: z.array(familyCoverageSchema).length(12)
-		});
-		javaScriptSemanticGraphInputSchema = z.strictObject({
-			schema: z.literal("JavaScriptSemanticRelationGraph"),
-			root_artifact_sha256: digestSchema,
-			application_graph_id: prefixedDigestSchema("jag"),
-			root_node_ids: z.array(semanticNodeIdSchema).min(1),
-			evidence_contexts: z.array(javaScriptSemanticEvidenceContextSchema),
-			nodes: z.array(javaScriptSemanticNodeSchema).min(1),
-			relations: z.array(javaScriptSemanticRelationSchema),
-			fingerprints: z.array(javaScriptSemanticFingerprintSchema),
-			unknowns: z.array(javaScriptSemanticUnknownSchema),
-			coverage: graphCoverageSchema,
-			limitations: z.array(boundedTextSchema)
+		validatedImmutableApplicationGraphs = new WeakSet();
+		createImmutableJavaScriptApplicationGraphSteps = (input) => sealValidatedApplicationGraphSteps(createJavaScriptApplicationGraph(input));
+		applicationGraphShape = javascriptApplicationGraphInputSchema.shape;
+		applicationGraphContainerSchema = javascriptApplicationGraphInputSchema.extend({
+			nodes: arrayContainerSchema(applicationGraphShape.nodes),
+			edges: arrayContainerSchema(applicationGraphShape.edges)
 		});
-		javaScriptSemanticGraphRecordSchema = javaScriptSemanticGraphInputSchema.extend({ graph_id: prefixedDigestSchema("jsrg") });
+		sealTransferredJavaScriptApplicationGraphSteps = (input) => parseAndSealApplicationGraphSteps(applicationGraphContainerSchema.parse(input));
+		isValidatedImmutableJavaScriptApplicationGraph = (value) => typeof value === "object" && value !== null && validatedImmutableApplicationGraphs.has(value);
+		parseJavaScriptApplicationGraph = (input) => javascriptApplicationGraphSchema.parse(input);
+		computeJavaScriptApplicationGraphSha256 = (input) => digestCanonicalValue(parseJavaScriptApplicationGraph(input), "JavaScript Application Graph");
+		serializeJavaScriptApplicationGraph = (input) => canonicalJson(parseJavaScriptApplicationGraph(input), "JavaScript Application Graph");
 	})))();
 }
 
 //#endregion
 //#region dist/domain/javascript/javascriptSemanticGraph.js
 function* checkCoverageSteps(graph, context) {
+	const omittedUnknowns = graph.coverage.omitted_unknown_occurrences ?? [];
+	sortedUniqueIssue(omittedUnknowns.map(({ family, reason }) => `${family}:${reason}`), ["coverage", "omitted_unknown_occurrences"], "Unknown omission coverage", context);
+	if (omittedUnknowns.length > 0 && (!graph.coverage.truncated || graph.coverage.status !== "partial")) context.addIssue({
+		code: "custom",
+		path: ["coverage"],
+		message: "Omitted unknown occurrences require truncated partial coverage"
+	});
 	const families = graph.coverage.families.map(({ family }) => family);
 	if (canonicalJson(families, "JavaScript semantic graph") !== canonicalJson(JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, "JavaScript semantic graph")) context.addIssue({
 		code: "custom",
@@ -1338,7 +1352,7 @@ function* checkCoverageSteps(graph, context) {
 			],
 			message: "Family coverage references an unknown from another family"
 		});
-		if (family.status === "complete" && (family.omitted_relations !== 0 || family.unknown_ids.length > 0 || unknownFamilies.has(family.family))) context.addIssue({
+		if (family.status === "complete" && (family.omitted_relations !== 0 || family.unknown_ids.length > 0 || unknownFamilies.has(family.family) || omittedUnknowns.some((omitted) => omitted.family === family.family))) context.addIssue({
 			code: "custom",
 			path: [
 				"coverage",
@@ -1834,6 +1848,7 @@ function init_javascriptSemanticGraph() {
 			coverage: {
 				...parsed.coverage,
 				limits: [...parsed.coverage.limits].sort((left, right) => compareUnicodeCodePoints(canonicalJson(left, "JavaScript semantic graph"), canonicalJson(right, "JavaScript semantic graph"))),
+				...parsed.coverage.omitted_unknown_occurrences === undefined ? {} : { omitted_unknown_occurrences: [...parsed.coverage.omitted_unknown_occurrences].sort((left, right) => compareUnicodeCodePoints(`${left.family}:${left.reason}`, `${right.family}:${right.reason}`)) },
 				families: [...parsed.coverage.families].map((family) => ({
 					...family,
 					unknown_ids: uniqueSorted(family.unknown_ids)
@@ -1880,16 +1895,18 @@ function init_artifactIntegrityPolicy() {
 
 //#endregion
 //#region dist/domain/javascript/javascriptAnalysisResourceControls.js
-var JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS, JAVASCRIPT_SEMANTIC_NODE_MAXIMUM, javaScriptAnalysisCoverageLimits, javaScriptAnalysisResourceControlsSchema;
+var JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS, JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM, javaScriptAnalysisCoverageLimits, javaScriptAnalysisResourceControlsSchema;
 function init_javascriptAnalysisResourceControls() {
 	return (init_javascriptAnalysisResourceControls = __esmMin((() => {
 		JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS = {
 			heapMb: 1024,
 			timeoutMs: 3e5,
 			semanticNodes: 1e5,
-			semanticNodesPerFile: 2e4
+			semanticNodesPerFile: 2e4,
+			semanticUnknowns: 1e5,
+			semanticUnknownsPerFile: 2e4
 		};
-		JAVASCRIPT_SEMANTIC_NODE_MAXIMUM = 1e6;
+		JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM = 1e6;
 		javaScriptAnalysisCoverageLimits = (limits) => {
 			const result = [];
 			for (const key of [
@@ -1913,8 +1930,10 @@ function init_javascriptAnalysisResourceControls() {
 			return result;
 		};
 		javaScriptAnalysisResourceControlsSchema = z.strictObject({
-			max_semantic_nodes: z.number().int().min(1).max(JAVASCRIPT_SEMANTIC_NODE_MAXIMUM).optional().describe("Maximum retained semantic nodes across the application; defaults to 100000. Worker heap and parent result admission remain enforced."),
-			max_semantic_nodes_per_file: z.number().int().min(1).max(JAVASCRIPT_SEMANTIC_NODE_MAXIMUM).optional().describe("Maximum retained semantic nodes per source file; defaults to 20000, additionally bounded by max_semantic_nodes and memory/transfer limits."),
+			max_semantic_nodes: z.number().int().min(1).max(JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM).optional().describe("Maximum retained semantic nodes across the application; defaults to 100000. Worker heap and parent result admission remain enforced."),
+			max_semantic_nodes_per_file: z.number().int().min(1).max(JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM).optional().describe("Maximum retained semantic nodes per source file; defaults to 20000, additionally bounded by max_semantic_nodes and memory/transfer limits."),
+			max_semantic_unknowns: z.number().int().min(1).max(JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM).optional().describe("Maximum retained semantic unknown records across the application; defaults to 100000. Omitted emission occurrences are counted by family and reason."),
+			max_semantic_unknowns_per_file: z.number().int().min(1).max(JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM).optional().describe("Maximum retained semantic unknown records per source file; defaults to 20000, additionally bounded by max_semantic_unknowns and memory/transfer limits."),
 			max_heap_mb: z.number().int().min(128).max(16384).optional().describe("Maximum V8 old-space heap in MiB for the isolated JavaScript source analyzer; defaults to 1024. This does not change the CLI/MCP process heap. When REA runs on Bun, which ignores V8 heap flags, Windows instead limits the analyzer's committed memory to this budget plus a 512 MiB runtime reserve; other Bun hosts enforce no limit."),
 			analysis_timeout_ms: z.number().int().min(1).max(2147483647).optional().describe("Maximum startup, analysis and transfer time per JavaScript source, in milliseconds; defaults to 300000. On timeout, return collected partial Evidence and stop the analysis.")
 		});
@@ -2034,6 +2053,7 @@ function init_javascriptApplicationAnalysis() {
 			text_bytes_read: countSchema,
 			invalid_utf8_files: countSchema,
 			parsed_javascript_files: countSchema,
+			skipped_javascript_files: countSchema.exactOptional(),
 			visited_ast_nodes: countSchema,
 			findings: countSchema,
 			modules: countSchema,
@@ -2065,4 +2085,4 @@ function init_javascriptApplicationAnalysis() {
 }
 
 //#endregion
-export { JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS, JAVASCRIPT_APPLICATION_NODE_KINDS, JAVASCRIPT_SEMANTIC_NODE_KINDS, JAVASCRIPT_SEMANTIC_NODE_MAXIMUM, JAVASCRIPT_SEMANTIC_RELATIONS, JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, JAVASCRIPT_SEMANTIC_RELATION_FAMILY, JavaScriptSemanticEvidenceContextRegistry, analyzeJavaScriptApplicationInputSchema, artifactIntegrityPolicySchema, completeApplicationCoverage, createImmutableJavaScriptApplicationGraphSteps, createJavaScriptApplicationEdge, createJavaScriptApplicationGraph, createJavaScriptApplicationNode, createJavaScriptSemanticFingerprint, createJavaScriptSemanticGraph, createJavaScriptSemanticGraphNode, createJavaScriptSemanticGraphRelation, createJavaScriptSemanticGraphUnknown, init_artifactIntegrityPolicy, init_javascriptAnalysisResourceControls, init_javascriptApplicationAnalysis, init_javascriptApplicationEvidenceSchemas, init_javascriptApplicationGraph, init_javascriptApplicationGraphSchemas, init_javascriptSemanticGraph, init_javascriptSemanticGraphSchemas, init_javascriptSourceMapPaths, init_javascriptSourceSelection, isValidatedImmutableJavaScriptApplicationGraph, javaScriptAnalysisCoverageLimits, javaScriptAnalysisResourceControlsSchema, javaScriptSemanticEvidenceContextSchema, javaScriptSemanticFingerprintSchema, javaScriptSemanticNodeId, javaScriptSemanticNodeSchema, javaScriptSemanticRelationSchema, javaScriptSemanticUnknownSchema, javaScriptSourcePathsSchema, javaScriptSourceSelectionSchema, javascriptApplicationAnalysisResultSchema, javascriptApplicationGraphSchema, parseOwnedJavaScriptApplicationAnalysisSteps, partialApplicationCoverage, resolveJavaScriptSourceMapReferences, resolveJavaScriptSourceMapUrl, sealTransferredJavaScriptApplicationGraphSteps, sealTransferredJavaScriptSemanticGraphSteps, truncatedApplicationCoverage };
+export { JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS, JAVASCRIPT_APPLICATION_NODE_KINDS, JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM, JAVASCRIPT_SEMANTIC_NODE_KINDS, JAVASCRIPT_SEMANTIC_RELATIONS, JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, JAVASCRIPT_SEMANTIC_RELATION_FAMILY, JavaScriptSemanticEvidenceContextRegistry, analyzeJavaScriptApplicationInputSchema, applicationCoverageSchema, applicationGraphEvidenceSchema, applicationNodeIdentitySchema, applicationNodeObservationSchema, applicationNodeSchema, artifactIntegrityPolicySchema, completeApplicationCoverage, createImmutableJavaScriptApplicationGraphSteps, createJavaScriptApplicationEdge, createJavaScriptApplicationGraph, createJavaScriptApplicationNode, createJavaScriptSemanticFingerprint, createJavaScriptSemanticGraph, createJavaScriptSemanticGraphNode, createJavaScriptSemanticGraphRelation, createJavaScriptSemanticGraphUnknown, init_artifactIntegrityPolicy, init_javascriptAnalysisResourceControls, init_javascriptApplicationAnalysis, init_javascriptApplicationEvidenceSchemas, init_javascriptApplicationGraph, init_javascriptApplicationGraphSchemas, init_javascriptSemanticGraph, init_javascriptSemanticGraphSchemas, init_javascriptSourceMapPaths, init_javascriptSourceSelection, isValidatedImmutableJavaScriptApplicationGraph, javaScriptAnalysisCoverageLimits, javaScriptAnalysisResourceControlsSchema, javaScriptSemanticEvidenceContextSchema, javaScriptSemanticFingerprintSchema, javaScriptSemanticGraphInputSchema, javaScriptSemanticNodeId, javaScriptSemanticNodeSchema, javaScriptSemanticRelationSchema, javaScriptSemanticUnknownOmissionsSchema, javaScriptSemanticUnknownSchema, javaScriptSourcePathsSchema, javaScriptSourceSelectionSchema, javascriptApplicationAnalysisResultSchema, javascriptApplicationGraphSchema, parseOwnedJavaScriptApplicationAnalysisSteps, partialApplicationCoverage, resolveJavaScriptSourceMapReferences, resolveJavaScriptSourceMapUrl, sealTransferredJavaScriptApplicationGraphSteps, sealTransferredJavaScriptSemanticGraphSteps, truncatedApplicationCoverage };