rea-agents 6.5.0 → 6.7.0

package/dist/cli-runtime/{application__javascript__JavaScriptApplicationService-CCkp8KBh.js → application__javascript__JavaScriptApplicationService-o0uEsjEc.js}

@@ -1,29 +1,28 @@
 import { __esmMin } from "./rolldown-runtime-DXoylpqc.js";
-import { ELECTRON_IDENTITY_LIMITATION, ELECTRON_MODULE, STATIC_ROUTE_CALL_NAMES, analysisInputErrorFromIssues, analyzeParsedJavaScriptSemanticsSteps, argumentNode, argumentValue, calleeName, childNodes, chunkRuntime, classifyParsedJavaScriptOpenReceivers, classifyParsedJavaScriptOpenReceiversSteps, classifyParsedJavaScriptRpcClientRootsSteps, compareUnicodeCodePoints, completeSemanticSteps, compositeKey, createImmutableEvidenceSteps, createJavaScriptRpcScan, detectVendors, digestCanonicalValue, digestSchema, endpointArgument, err, factoryRequireName, failedJavaScriptStaticAnalysis, hasUncertainTypeOnlyModuleSideEffect, indexJavaScriptBindingsSteps, indexJavaScriptElectronIdentitySteps, init_artifactIdentity, init_browserObservation, init_canonicalDigest, init_digests, init_evidence, init_inputIssueProjection, init_javascriptAstValues, init_javascriptBootstrap, init_javascriptElectronMemberWrites, init_javascriptModuleDeclaration, init_javascriptRpcEndpoints, init_javascriptSemanticAmbientWrites, init_javascriptSemanticAnalysis, init_javascriptSemanticCoverage, init_javascriptSemanticProjection, init_javascriptSemanticRequireOrigin, init_javascriptSemanticResourceLimits, init_javascriptSemanticSlots, init_javascriptSemanticState, init_javascriptSemanticTraversal, init_javascriptSourceParser, init_javascriptStaticAnalysisHelpers, init_result, init_unicodeCodePointOrder, isTypeOnlyExportDeclaration, isTypeOnlyExportSpecifier, isTypeOnlyImportDeclaration, isTypeOnlyImportSpecifier, isUnmodifiedGlobalReference, isUnmodifiedImportMetaUrl, javascriptBootstrapAt, javascriptDisplayText, logicalPathEscapesRoot, moduleFactory, modulePropertyName, normalizeJoinedLogicalPath, ok, parseJavaScriptSource, prefixedArgument, propertyName, range as range$1, rangeForOffsets, readExactJavaScriptLiteral, registrationKey, resolveSemanticBindingState, runtimeFunctionParameters, sanitizeEndpointCandidate, semanticContainer, semanticCoverageResourceLimits, semanticFactoryLoaderMemberAt, semanticFactoryRequireLoaderAt, semanticImportEqualsSpecifier, semanticPropertyPointer, semanticRequireLoaderAt, semanticResolutionBlocked, semanticResourceLimitCoverage, semanticResourceLimitReason, semanticSlotAtPath, semanticStaticPropertyKey, semanticStaticPropertyName, semanticWriteSiteTarget, semanticWriteTargets, sha256Text, sortedUnique, sourceRangesEqual, sourceSlice, staticArrayValues, staticPath, staticPathResolutionContext, storageKind, stringValue, traverseJavaScriptAst, traverseJavaScriptAstSteps, unwrapJavaScriptExpression } from "./reconstructionObligationLedgerSchemas-Bao0xMr-.js";
-import { ANALYSIS_RESOURCE_KINDS, AnalysisAccessDeniedError, AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisError, AnalysisInputError, AnalysisOutputError, AnalysisResourceConstraintError, AnalysisTimeoutError, AnalysisUnsupportedTargetError, freezeJsonSnapshot, freezeOwnedJsonSnapshotSteps, init_analysisErrorBase, init_analysisErrorCore, init_immutableJson, init_jsonValue, jsonValueSchema, jsonValueValidationSteps } from "./errorSchemas-CTRmvMl3.js";
-import { ArtifactReaderFailure, init_ArtifactReader } from "./ArtifactReader-BXkffc1D.js";
-import { ProviderAdapterError, init_providerAdapterError } from "./providerAdapterError-DAjhICdr.js";
-import { ArtifactOperationError, init_artifactOperationError } from "./artifactOperationError-B7n03FbD.js";
-import { init_analysisErrorProjection, projectAnalysisError } from "./cliResultOutput-DsRMI8CJ.js";
-import { ProviderCleanupError, init_providerCleanupError } from "./providerCleanupError-Ceq8f0wK.js";
-import { ProviderProcessSupervisor, init_ProviderProcess, spawnOwnedProviderProcess } from "./snapshotEnvironment-D_tWyOub.js";
-import { cleanupOwnedProcessGroup, init_ProcessOwnership, init_ProcessOwnershipObservation, prepareProcessOwnershipInspection } from "./ProcessOwnership-DXC5-UWt.js";
-import { ProviderStartupDeadline, init_ProviderDeadline, waitForAbortableDelay } from "./ProviderDeadline-8m2pFRDc.js";
-import { PrivateRuntimeRoot, PrivateRuntimeRootUnavailableError, init_PrivateRuntimeRoot, init_PrivateRuntimeRootUnavailableError } from "./PrivateRuntimeRoot-DAy0PiBM.js";
-import { JAVASCRIPT_APPLICATION_PROVIDER, init_InvestigationProviders } from "./InvestigationProviders-DoQRIHii.js";
-import { JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS, JAVASCRIPT_SEMANTIC_NODE_MAXIMUM, JAVASCRIPT_SEMANTIC_RELATIONS, JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, JAVASCRIPT_SEMANTIC_RELATION_FAMILY, JavaScriptSemanticEvidenceContextRegistry, analyzeJavaScriptApplicationInputSchema, artifactIntegrityPolicySchema, completeApplicationCoverage, createJavaScriptApplicationEdge, createJavaScriptApplicationGraph, createJavaScriptApplicationNode, createJavaScriptSemanticFingerprint, createJavaScriptSemanticGraph, createJavaScriptSemanticGraphNode, createJavaScriptSemanticGraphRelation, createJavaScriptSemanticGraphUnknown, init_artifactIntegrityPolicy, init_javascriptAnalysisResourceControls, init_javascriptApplicationAnalysis, init_javascriptApplicationEvidenceSchemas, init_javascriptApplicationGraph, init_javascriptSemanticGraph, init_javascriptSemanticGraphSchemas, init_javascriptSourceMapPaths, init_javascriptSourceSelection, javaScriptAnalysisCoverageLimits, javaScriptAnalysisResourceControlsSchema, javaScriptSemanticEvidenceContextSchema, javaScriptSemanticFingerprintSchema, javaScriptSemanticNodeId, javaScriptSemanticNodeSchema, javaScriptSemanticRelationSchema, javaScriptSemanticUnknownSchema, javaScriptSourcePathsSchema, parseOwnedJavaScriptApplicationAnalysisSteps, partialApplicationCoverage, resolveJavaScriptSourceMapReferences, sealTransferredJavaScriptApplicationGraphSteps, sealTransferredJavaScriptSemanticGraphSteps, truncatedApplicationCoverage } from "./javascriptApplicationAnalysis-HgMzVMQw.js";
-import { ArtifactPathRegistry, init_ArtifactPaths, init_StreamBytes, normalizeArtifactPath, streamChunkToBuffer } from "./MachoLoadCommandReader-C7e074Ze.js";
+import { ELECTRON_IDENTITY_LIMITATION, ELECTRON_MODULE, STATIC_ROUTE_CALL_NAMES, analysisInputErrorFromIssues, analyzeParsedJavaScriptSemanticsSteps, argumentNode, argumentValue, calleeName, childNodes, chunkRuntime, compareUnicodeCodePoints, completeSemanticSteps, compositeKey, createImmutableEvidenceSteps, createJavaScriptRpcScan, detectVendors, digestCanonicalValue, digestSchema, endpointArgument, err, evaluateSemanticExpression, evaluateSemanticExpressionProvenance, factoryRequireName, failedJavaScriptStaticAnalysis, hasUncertainTypeOnlyModuleSideEffect, indexJavaScriptBindingsWithReceiversSteps, indexJavaScriptElectronIdentitySteps, init_artifactIdentity, init_browserObservation, init_canonicalDigest, init_digests, init_evidence, init_inputIssueProjection, init_javascriptAstValues, init_javascriptBootstrap, init_javascriptElectronMemberWrites, init_javascriptModuleDeclaration, init_javascriptRpcEndpoints, init_javascriptSemanticAmbientWrites, init_javascriptSemanticAnalysis, init_javascriptSemanticCoverage, init_javascriptSemanticMapOperations, init_javascriptSemanticMutationInitializers, init_javascriptSemanticPropertyPaths, init_javascriptSemanticRequireOrigin, init_javascriptSemanticResourceLimits, init_javascriptSemanticSlots, init_javascriptSemanticState, init_javascriptSemanticTraversal, init_javascriptSemanticValues, init_javascriptSourceParser, init_javascriptStaticAnalysisHelpers, init_result, init_unicodeCodePointOrder, isIntrinsicMapLookup, isTypeOnlyExportDeclaration, isTypeOnlyExportSpecifier, isTypeOnlyImportDeclaration, isTypeOnlyImportSpecifier, isUnmodifiedGlobalReference, isUnmodifiedImportMetaUrl, javascriptBootstrapAt, javascriptDisplayText, logicalPathEscapesRoot, moduleFactory, modulePropertyName, normalizeJoinedLogicalPath, ok, parseJavaScriptSource, prefixedArgument, propertyName, range as range$1, rangeForOffsets, readExactJavaScriptLiteral, registrationKey, resolveSemanticBindingState, runtimeFunctionParameters, sanitizeEndpointCandidate, semanticArrayIndex, semanticBindingAtRead, semanticContainer, semanticCoverageResourceLimits, semanticFactoryLoaderMemberAt, semanticFactoryRequireLoaderAt, semanticImportEqualsSpecifier, semanticPropertyPointer, semanticRequireLoaderAt, semanticResolutionBlocked, semanticResourceLimitCoverage, semanticResourceLimitReason, semanticSlotAtPath, semanticStableInitializer, semanticStaticPropertyKey, semanticStaticPropertyName, semanticTopLevelEffectFollowsCapture, semanticWriteSiteTarget, semanticWriteTargets, sha256Text, sortedUnique, sourceRangesEqual, sourceSlice, staticArrayValues, staticObjectProperty, staticPath, staticPathResolutionContext, storageKind, stringValue, traverseJavaScriptAst, traverseJavaScriptAstSteps, unwrapJavaScriptExpression } from "./reconstructionObligationLedgerSchemas-Bi6sect1.js";
+import { ANALYSIS_RESOURCE_KINDS, AnalysisAccessDeniedError, AnalysisCancelledError, AnalysisCapabilityUnavailableError, AnalysisError, AnalysisInputError, AnalysisOutputError, AnalysisResourceConstraintError, AnalysisTimeoutError, AnalysisUnsupportedTargetError, freezeJsonSnapshot, freezeOwnedJsonSnapshotSteps, init_analysisErrorBase, init_analysisErrorCore, init_immutableJson, init_jsonValue, jsonValueSchema, jsonValueValidationSteps } from "./errorSchemas-Ixz_q7qt.js";
+import { ArtifactReaderFailure, init_ArtifactReader } from "./ArtifactReader-DMwm42bk.js";
+import { ArtifactOperationError, ProviderAdapterError, init_analysisErrorProjection, init_artifactOperationError, init_providerAdapterError, projectAnalysisError } from "./cliResultOutput-10sd6xGx.js";
+import { ProviderCleanupError, init_providerCleanupError } from "./providerCleanupError-BhsJyAhk.js";
+import { init_ProcessOwnershipObservation, prepareProcessOwnershipInspection } from "./ProcessOwnershipObservation-C006iCtZ.js";
+import { ProviderProcessSupervisor, init_ProviderProcess, spawnOwnedProviderProcess } from "./ProviderProcess-D87A7ctp.js";
+import { cleanupOwnedProcessGroup, init_ProcessOwnership } from "./ProcessOwnership-CtrNr6ee.js";
+import { ProviderStartupDeadline, init_ProviderDeadline, waitForAbortableDelay } from "./ProviderDeadline-rSuH4Pm8.js";
+import { PrivateRuntimeRoot, PrivateRuntimeRootUnavailableError, init_PrivateRuntimeRoot, init_PrivateRuntimeRootUnavailableError } from "./PrivateRuntimeRoot-Cd23u6jd.js";
+import { JAVASCRIPT_APPLICATION_PROVIDER, init_InvestigationProviders } from "./InvestigationProviders-CFh4a64d.js";
+import { JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS, JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM, JAVASCRIPT_SEMANTIC_RELATIONS, JAVASCRIPT_SEMANTIC_RELATION_FAMILIES, JAVASCRIPT_SEMANTIC_RELATION_FAMILY, JavaScriptSemanticEvidenceContextRegistry, analyzeJavaScriptApplicationInputSchema, artifactIntegrityPolicySchema, completeApplicationCoverage, createJavaScriptApplicationEdge, createJavaScriptApplicationGraph, createJavaScriptApplicationNode, createJavaScriptSemanticFingerprint, createJavaScriptSemanticGraph, createJavaScriptSemanticGraphNode, createJavaScriptSemanticGraphRelation, createJavaScriptSemanticGraphUnknown, init_artifactIntegrityPolicy, init_javascriptAnalysisResourceControls, init_javascriptApplicationAnalysis, init_javascriptApplicationEvidenceSchemas, init_javascriptApplicationGraph, init_javascriptSemanticGraph, init_javascriptSemanticGraphSchemas, init_javascriptSourceMapPaths, init_javascriptSourceSelection, javaScriptAnalysisCoverageLimits, javaScriptAnalysisResourceControlsSchema, javaScriptSemanticEvidenceContextSchema, javaScriptSemanticFingerprintSchema, javaScriptSemanticNodeId, javaScriptSemanticNodeSchema, javaScriptSemanticRelationSchema, javaScriptSemanticUnknownOmissionsSchema, javaScriptSemanticUnknownSchema, javaScriptSourcePathsSchema, parseOwnedJavaScriptApplicationAnalysisSteps, partialApplicationCoverage, resolveJavaScriptSourceMapReferences, sealTransferredJavaScriptApplicationGraphSteps, sealTransferredJavaScriptSemanticGraphSteps, truncatedApplicationCoverage } from "./javascriptApplicationAnalysis-Dk6yBV8g.js";
 import { flattenSourceMapLeaves, init_JavaScriptWorkerMemoryLimit, init_TypeScriptEmittedSourceCandidates, init_javascriptModuleSpecifier, init_sourceMapEnvelope, isRelativeJavaScriptModuleSpecifier, javaScriptWorkerMemoryLimitBytes, sourceMapJsonText, typescriptEmittedSourceCandidates } from "./JavaScriptWorkerMemoryLimit-B1bwMM1a.js";
+import { ArtifactPathRegistry, DirectoryArtifactReader, init_ArtifactPaths, init_DirectoryArtifactReader, init_StreamBytes, normalizeArtifactPath, streamChunkToBuffer } from "./DirectoryArtifactReader-CokAJ8vo.js";
 import { init_runtimeVersion, javaScriptRuntime } from "./runtimeVersion-CMGd0bDu.js";
-import { init_javascriptExportReturnShapeProjection, projectJavaScriptExportReturnShapes } from "./javascriptExportReturnShapeProjection-Dg00g35t.js";
-import { init_JavaScriptApplicationEvidenceGraph, rememberOwnedApplicationGraphEvidence } from "./JavaScriptApplicationEvidenceGraph-D5aI_FSJ.js";
-import { AsarArtifactReader, DirectoryArtifactReader, hashReadable, init_ArtifactHash, init_AsarArtifactReader, init_DirectoryArtifactReader, init_javascriptArtifactFiles, init_scanCanonical, isJavaScriptSourcePath, scanCanonicalArtifactInventoryInScope } from "./scanCanonical-KP4T9jSl.js";
+import { init_javascriptExportReturnShapeProjection, projectJavaScriptExportReturnShapes } from "./javascriptExportReturnShapeProjection-CObOIiQ6.js";
+import { init_JavaScriptApplicationEvidenceGraph, rememberOwnedApplicationGraphEvidence } from "./JavaScriptApplicationEvidenceGraph-gOmPB2L6.js";
+import { AsarArtifactReader, hashReadable, init_ArtifactHash, init_AsarArtifactReader, init_javascriptArtifactFiles, init_scanCanonical, isJavaScriptSourcePath, scanCanonicalArtifactInventoryInScope } from "./scanCanonical-CcDFUr-w.js";
 import { isBuiltin } from "node:module";
 import { z } from "zod";
 import { isAbsolute, join, posix } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
-import { access, lstat, open, readFile, realpath, rm, stat, writeFile } from "node:fs/promises";
 import { constants, createReadStream } from "node:fs";
+import { access, lstat, open, readFile, realpath, rm, stat, writeFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { setImmediate } from "node:timers/promises";
 import { getHeapStatistics } from "node:v8";
@@ -117,6 +116,8 @@ function init_JavaScriptApplicationEvidence() {
 			integrity_policy: input.integrity_policy,
 			...input.max_semantic_nodes === undefined ? {} : { max_semantic_nodes: input.max_semantic_nodes },
 			...input.max_semantic_nodes_per_file === undefined ? {} : { max_semantic_nodes_per_file: input.max_semantic_nodes_per_file },
+			...input.max_semantic_unknowns === undefined ? {} : { max_semantic_unknowns: input.max_semantic_unknowns },
+			...input.max_semantic_unknowns_per_file === undefined ? {} : { max_semantic_unknowns_per_file: input.max_semantic_unknowns_per_file },
 			...input.source_paths === undefined ? {} : { source_paths: input.source_paths },
 			...input.max_heap_mb === undefined ? {} : { max_heap_mb: input.max_heap_mb },
 			...input.analysis_timeout_ms === undefined ? {} : { analysis_timeout_ms: input.analysis_timeout_ms }
@@ -171,6 +172,7 @@ function init_javascriptSymbolicValues() {
 			};
 		};
 		symbolicTruth = (value) => {
+			if (value.kind === "namespace" && value.runtimeValueUnknown) return undefined;
 			if (value.kind === "union") {
 				const choices = value.values.map(symbolicTruth);
 				return choices.length > 0 && choices.every((choice) => choice === choices[0]) ? choices[0] : undefined;
@@ -181,7 +183,9 @@ function init_javascriptSymbolicValues() {
 				"namespace",
 				"array",
 				"record",
-				"loader"
+				"loader",
+				"promise",
+				"iterator"
 			].includes(value.kind) ? true : undefined;
 		};
 		symbolicCondition = (value, condition) => {
@@ -208,6 +212,7 @@ function init_javascriptSymbolicControlFlow() {
 	return (init_javascriptSymbolicControlFlow = __esmMin((() => {
 		init_javascriptSymbolicValues();
 		symbolicLogicalRight = (operator, left) => {
+			if (left.kind === "namespace" && left.runtimeValueUnknown) return undefined;
 			if (left.kind === "union") {
 				const choices = left.values.map((value) => symbolicLogicalRight(operator, value));
 				return choices.length > 0 && choices.every((choice) => choice === choices[0]) ? choices[0] : undefined;
@@ -220,7 +225,9 @@ function init_javascriptSymbolicControlFlow() {
 					"namespace",
 					"array",
 					"record",
-					"loader"
+					"loader",
+					"promise",
+					"iterator"
 				].includes(left.kind) ? false : undefined;
 			}
 			const truth = symbolicTruth(left);
@@ -244,6 +251,7 @@ function init_javascriptSymbolicBindings() {
 		init_javascriptBootstrap();
 		init_javascriptElectronMemberWrites();
 		init_javascriptSemanticAnalysis();
+		init_javascriptSemanticPropertyPaths();
 		init_javascriptSymbolicControlFlow();
 		init_javascriptStaticAnalysisHelpers();
 		init_javascriptSemanticTraversal();
@@ -270,7 +278,8 @@ function init_javascriptSymbolicBindings() {
 			#activeFunctions = new Set();
 			#exportAliases = new Map();
 			#moduleBindings = new Set();
-			#replacements = new Map();
+			#completedModules = new WeakMap();
+			#completionGroups = new WeakMap();
 			#propertyActive = new WeakMap();
 			#literalPropertyIndex = new WeakMap();
 			#mutated = new Set();
@@ -339,26 +348,57 @@ function init_javascriptSymbolicBindings() {
 					this.#depth -= 1;
 				}
 			}
-			property(value, key) {
+			#withConditions(value, source) {
+				const conditions = source.conditions ?? [];
+				if (conditions.length === 0 && !source.conditionUnresolved) return value;
+				const variants = symbolicVariants(value);
+				for (const variant of variants) {
+					const cost = 1 + (conditions.length ? conditions.length + (variant.conditions?.length ?? 0) : 0);
+					if (cost > this.#remainingEvaluations) {
+						this.#remainingEvaluations = 0;
+						this.truncated = true;
+						return symbolicUnknown("symbolic condition resource limit");
+					}
+					this.#remainingEvaluations -= cost;
+				}
+				return symbolicUnion(variants.map((variant) => ({
+					...variant,
+					...conditions.length ? { conditions: [...variant.conditions ?? [], ...conditions] } : {},
+					...source.conditionUnresolved ? { conditionUnresolved: true } : {}
+				})));
+			}
+			property(value, key, read) {
 				let result;
-				if (value.kind === "union") result = symbolicUnion(value.values.map((variant) => this.property(variant, key)));
-				else result = this.#property(value, key);
-				for (const condition of value.conditions ?? []) result = symbolicCondition(result, condition);
-				if (value.conditionUnresolved) result = symbolicConditionsUnresolved(result);
-				return result;
+				if (value.kind === "union") result = symbolicUnion([...this.#commonProperty(value.values, key, read), ...value.values.map((variant) => this.property(variant, key, read))]);
+				else result = this.#property(value, key, read);
+				return this.#withConditions(result, value);
+			}
+			#commonProperty(values, key, read) {
+				const first = values[0];
+				const group = first === undefined ? undefined : this.#completionGroups.get(first);
+				if (group === undefined || group.members.size !== values.length) return [];
+				if (values.length > this.#remainingEvaluations) {
+					this.truncated = true;
+					this.#remainingEvaluations = 0;
+					return [];
+				}
+				this.#remainingEvaluations -= values.length;
+				if (!values.every((value) => group.members.has(value))) return [];
+				const common = this.property(group.common, key, read);
+				return common.kind === "unknown" ? [] : [common];
 			}
-			#property(value, key) {
+			#property(value, key, read) {
 				const active = this.#propertyActive.get(value) ?? new Set();
 				if (active.has(key)) return symbolicUnknown("cyclic property");
 				active.add(key);
 				this.#propertyActive.set(value, active);
 				try {
-					return this.#propertyValue(value, key);
+					return this.#propertyValue(value, key, read);
 				} finally {
 					active.delete(key);
 				}
 			}
-			#propertyValue(value, key) {
+			#propertyValue(value, key, read) {
 				if (value.kind === "external") {
 					const path = [...value.path, key];
 					if (ELECTRON_MODULE.test(path[0] ?? "") && !this.#electronIdentity.intactExport(path)) {
@@ -369,12 +409,26 @@ function init_javascriptSymbolicBindings() {
 						path
 					};
 				}
-				if (value.kind === "record") return value.values.get(key) ?? symbolicUnknown("missing property");
+				if (value.kind === "record") {
+					const property = value.values.get(key);
+					if (key === "exports" && property?.kind === "namespace" && this.#namespaceOwners.has(property.bindingId)) {
+						return {
+							...property,
+							runtimeValueUnknown: true
+						};
+					}
+					return property ?? symbolicUnknown("missing property");
+				}
 				if (value.kind === "namespace") {
 					if (this.#mutated.has(value.bindingId) || this.#unsafeExports.has(`${value.bindingId}:${key}`)) return symbolicUnknown("ambiguous export writes");
-					const replacement = this.#replacements.get(value.bindingId);
-					if (replacement) return this.property(this.evaluate(replacement, value.environment), key);
-					const writes = (this.#writes.get(value.bindingId) ?? []).filter((w) => w.path.length === 1 && w.path[0] === key);
+					const available = this.#namespaceWrites(value, read, key);
+					if (available === undefined) {
+						this.unresolved = true;
+						return symbolicUnknown("module export read boundary is unavailable");
+					}
+					const replacement = available.findLast((write) => write.path.length === 0);
+					if (replacement) return this.property(this.evaluate(replacement.value, value.environment), key, read);
+					const writes = available.filter((w) => w.path.length === 1 && w.path[0] === key);
 					const write = writes.at(-1);
 					return write ? this.evaluate(write.value, value.environment) : symbolicUnknown("unresolved module export");
 				}
@@ -406,7 +460,10 @@ function init_javascriptSymbolicBindings() {
 					for (const p of [...value.node.properties].reverse()) {
 						if (t.isSpreadElement(p)) {
 							const spread = this.evaluate(p.argument, value.environment);
-							const found = this.property(spread, key);
+							const found = this.property(spread, key, {
+								node: p.argument,
+								environment: value.environment
+							});
 							if (found.kind !== "unknown") return found;
 							if (this.unknownMembers(spread) > 0 || this.members(spread).includes(key)) return found;
 						} else if (semanticStaticPropertyKey(p.key, p.computed) === key) {
@@ -414,7 +471,14 @@ function init_javascriptSymbolicBindings() {
 						} else if (semanticStaticPropertyKey(p.key, p.computed) === null) return symbolicUnknown("dynamic property overwrite");
 					}
 				}
-				if (value.kind === "array" && /^\d+$/u.test(key)) return value.values[Number(key)] ?? symbolicUnknown("missing argument");
+				if (value.kind === "array") {
+					const index = semanticArrayIndex(key);
+					if (index !== null) return value.values[index] ?? symbolicUnknown("missing argument");
+				}
+				if (value.kind === "iterator" || value.kind === "promise") {
+					this.unresolved = true;
+					return symbolicUnknown(`${value.kind} members are not modeled`);
+				}
 				return symbolicUnknown("unresolved property");
 			}
 			#objectPropertyValue(property, environment) {
@@ -426,8 +490,10 @@ function init_javascriptSymbolicBindings() {
 				if (value.kind === "union") return [...new Set(value.values.flatMap((v) => this.members(v, active)))];
 				if (value.kind === "record") return [...value.values.keys()];
 				if (value.kind === "namespace") {
-					const replacement = this.#replacements.get(value.bindingId);
-					return replacement ? this.members(this.evaluate(replacement, value.environment), active) : [...new Set((this.#writes.get(value.bindingId) ?? []).flatMap((w) => w.path.length === 1 ? w.path : []))];
+					const available = this.#namespaceWrites(value);
+					if (available === undefined) return [];
+					const replacement = available.findLast((write) => write.path.length === 0);
+					return replacement ? this.members(this.evaluate(replacement.value, value.environment), active) : [...new Set(available.flatMap((w) => w.path.length === 1 ? w.path : []))];
 				}
 				if (value.kind !== "object") return [];
 				return [...new Set(value.node.properties.flatMap((p) => t.isSpreadElement(p) ? this.members(this.evaluate(p.argument, value.environment), active) : [semanticStaticPropertyKey(p.key, p.computed)].filter((k) => k !== null && !isObjectPrototypeSetter(p, k))))];
@@ -439,13 +505,19 @@ function init_javascriptSymbolicBindings() {
 				if (value.kind === "record") return 0;
 				if (value.kind === "namespace") {
 					if (this.#mutated.has(value.bindingId)) return 1;
-					const replacement = this.#replacements.get(value.bindingId);
-					return replacement ? this.unknownMembers(this.evaluate(replacement, value.environment), active) : 0;
+					const available = this.#namespaceWrites(value);
+					if (available === undefined) return 1;
+					const replacement = available.findLast((write) => write.path.length === 0);
+					return replacement ? this.unknownMembers(this.evaluate(replacement.value, value.environment), active) : 0;
 				}
 				if (value.kind !== "object") return 1;
 				return value.node.properties.reduce((sum, p) => sum + (t.isSpreadElement(p) ? this.unknownMembers(this.evaluate(p.argument, value.environment), new Set(active)) : Number(semanticStaticPropertyKey(p.key, p.computed) === null)), 0);
 			}
-			bind(fn, args, invocationNode) {
+			/** Calling a generator creates an iterator; advancing it is not modeled. */
+			callBody(fn) {
+				return fn.node.generator ? undefined : fn.node.body;
+			}
+			bind(fn, args, invocationNode, caller) {
 				const values = new Map();
 				runtimeFunctionParameters(fn.node).forEach((param, index) => {
 					const target = t.isRestElement(param) ? param.argument : param;
@@ -459,7 +531,9 @@ function init_javascriptSymbolicBindings() {
 				const scopeId = this.state.scopeByNode.get(fn.node)?.scopeId ?? this.state.scopeByNode.get(fn.node.body)?.scopeId;
 				return {
 					values,
+					activation: {},
 					parent: fn.environment,
+					...caller === undefined ? {} : { caller },
 					point: invocationNode ?? fn.node,
 					scopeNode: fn.node,
 					...scopeId === undefined ? {} : { scopeId }
@@ -495,11 +569,18 @@ function init_javascriptSymbolicBindings() {
 				if (t.isIdentifier(node)) return this.#identifier(node, env);
 				if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
 					const key = semanticStaticPropertyKey(node.property, node.computed);
-					return key === null ? symbolicUnknown("dynamic member") : this.property(this.evaluate(node.object, env), key);
+					return key === null ? symbolicUnknown("dynamic member") : this.property(this.evaluate(node.object, env), key, {
+						node,
+						environment: env
+					});
 				}
 				if (t.isSequenceExpression(node)) return this.evaluate(node.expressions.at(-1), env);
-				if (t.isAssignmentExpression(node)) return this.evaluate(node.right, env);
-				if (t.isAwaitExpression(node)) return this.evaluate(node.argument, env);
+				if (t.isAssignmentExpression(node)) {
+					if (node.operator === "=") return this.evaluate(node.right, env);
+					if (node.operator === "&&=" || node.operator === "||=" || node.operator === "??=") return this.#logicalValue(node.operator === "&&=" ? "&&" : node.operator === "||=" ? "||" : "??", node.left, node.right, env, true);
+					return symbolicUnknown("compound assignment result");
+				}
+				if (t.isAwaitExpression(node)) return this.#awaited(this.evaluate(node.argument, env));
 				if (t.isUnaryExpression(node)) {
 					const value = this.evaluate(node.argument, env);
 					if (node.operator === "void") return {
@@ -522,23 +603,29 @@ function init_javascriptSymbolicBindings() {
 						positive: false
 					})]) : this.evaluate(truth ? node.consequent : node.alternate, env);
 				}
-				if (t.isLogicalExpression(node)) {
-					const left = this.evaluate(node.left, env);
-					const right = symbolicLogicalRight(node.operator, left);
-					if (right !== undefined) return right ? this.evaluate(node.right, env) : left;
-					const leftCondition = {
-						node: node.left,
-						positive: node.operator === "&&" ? false : node.operator === "||" ? true : "not-nullish"
-					};
-					const rightCondition = {
-						node: node.left,
-						positive: node.operator === "&&" ? true : node.operator === "||" ? false : "nullish"
-					};
-					return symbolicUnion([symbolicCondition(left, leftCondition), symbolicCondition(this.evaluate(node.right, env), rightCondition)]);
-				}
+				if (t.isLogicalExpression(node)) return this.#logicalValue(node.operator, node.left, node.right, env);
 				if (t.isCallExpression(node) || t.isOptionalCallExpression(node)) return this.#call(node, env);
 				return symbolicUnknown(`unsupported ${node.type}`);
 			}
+			#logicalValue(operator, leftNode, rightNode, env, assignment = false) {
+				const value = this.evaluate(leftNode, env);
+				let left = value;
+				if (assignment) {
+					const alternatives = symbolicUnion(symbolicVariants(value).map((variant) => variant.kind === "namespace" && variant.runtimeValueUnknown ? this.#withConditions(symbolicUnknown("mutable module exports value"), variant) : variant));
+					left = value.kind === "union" ? this.#withConditions(alternatives, value) : alternatives;
+				}
+				const right = symbolicLogicalRight(operator, left);
+				if (right !== undefined) return right ? this.evaluate(rightNode, env) : left;
+				const leftCondition = {
+					node: leftNode,
+					positive: operator === "&&" ? false : operator === "||" ? true : "not-nullish"
+				};
+				const rightCondition = {
+					node: leftNode,
+					positive: operator === "&&" ? true : operator === "||" ? false : "nullish"
+				};
+				return symbolicUnion([symbolicCondition(left, leftCondition), symbolicCondition(this.evaluate(rightNode, env), rightCondition)]);
+			}
 			#identifier(node, env) {
 				const binding = resolveSemanticBindingState(this.state, node, node.name);
 				if (!binding && node.name === "undefined" && !semanticResolutionBlocked(this.state, node, node.name)) return {
@@ -564,7 +651,8 @@ function init_javascriptSymbolicBindings() {
 				if (electronOrigin === undefined && this.#writes.has(binding.bindingId)) return symbolicUnknown("overwritten object members");
 				const initializer = binding.initializers.length === 1 ? binding.initializers[0] : undefined;
 				if (!initializer) return symbolicUnknown("missing or ambiguous initializer");
-				const point = this.#initializerReadPoint(binding.scopeId, env, node);
+				const boundary = this.#readBoundary(binding.scopeId, env, node);
+				const point = boundary === undefined ? undefined : boundary.node[boundary.edge];
 				if (!initializer.entryBody && !binding.definitions.every(({ kind }) => kind === "function") && (initializer.node.end == null || point == null || initializer.node.end > point)) {
 					this.unresolved = true;
 					return symbolicUnknown("initializer not available at this read");
@@ -573,19 +661,28 @@ function init_javascriptSymbolicBindings() {
 				let value = this.evaluate(initializer.node, env);
 				for (const key of initializer.projection) {
 					if (key === null) return symbolicUnknown("dynamic destructuring");
-					value = this.property(value, String(key));
+					value = this.property(value, String(key), {
+						node: initializer.node,
+						environment: env
+					});
 				}
 				return value;
 			}
-			#initializerReadPoint(bindingScopeId, environment, readNode) {
+			#readBoundary(bindingScopeId, environment, readNode) {
 				let current = environment;
 				let child;
 				while (current) {
 					if (this.#scopeContains(bindingScopeId, current.scopeId)) {
 						const point = child?.point ?? readNode;
-						if (current.completedAt !== undefined) return current.completedAt.end ?? undefined;
+						if (current.completedAt !== undefined) return {
+							node: current.completedAt,
+							edge: "end"
+						};
 						if (current.scopeNode && !this.#nodeWithin(point, current.scopeNode)) return undefined;
-						return point.start ?? undefined;
+						return {
+							node: point,
+							edge: "start"
+						};
 					}
 					child = current;
 					current = current.parent;
@@ -593,7 +690,10 @@ function init_javascriptSymbolicBindings() {
 				let outermost = environment;
 				while (outermost.parent) outermost = outermost.parent;
 				const point = outermost.point ?? environment.point ?? readNode;
-				return point.start ?? undefined;
+				return {
+					node: point,
+					edge: "start"
+				};
 			}
 			#scopeContains(bindingScopeId, environmentScopeId) {
 				let scopeId = bindingScopeId;
@@ -624,24 +724,162 @@ function init_javascriptSymbolicBindings() {
 					parent
 				};
 			}
-			#completeReturnedFunction(value, activation, returnPoint) {
-				const environment = this.#completedEnvironment(value.environment, activation, returnPoint);
-				if (environment === undefined) return value;
-				const { returnPoint: _returnPoint, ...returned } = value;
+			#awaited(value) {
+				return symbolicUnion(symbolicVariants(value).map((variant) => variant.kind === "promise" ? this.#withConditions(this.#awaited(variant.value), variant) : variant));
+			}
+			#completeReturnedValue(value, activation, fallbackPoint, origins) {
+				if (value.kind === "union") return symbolicUnion(value.values.map((variant) => this.#completeReturnedValue(variant, activation, fallbackPoint, origins)));
+				if (value.kind !== "function" && value.kind !== "promise") return value;
+				const { returnPoint, ...returned } = value;
+				const point = returnPoint ?? fallbackPoint;
+				if (returned.kind === "promise") return {
+					...returned,
+					value: this.#completeReturnedValue(returned.value, activation, point, origins)
+				};
+				const environment = this.#completedEnvironment(returned.environment, activation, point);
 				return {
 					...returned,
+					environment: environment ?? returned.environment,
+					origins: [...origins, ...returned.origins]
+				};
+			}
+			#namespaceReadBoundary(value, read) {
+				const scopeId = value.environment.scopeId;
+				const activation = value.environment.activation;
+				if (scopeId === undefined || activation === undefined) return undefined;
+				const captured = this.#hasActivation(read.environment, activation);
+				if (captured && this.#owningFunction(read.node) === value.environment.scopeNode) return {
+					node: read.node,
+					edge: "start"
+				};
+				const caller = this.#namespaceCallerBoundary(value, read.environment, activation);
+				if (caller !== undefined) return caller;
+				if (!captured) return undefined;
+				const boundary = this.#readBoundary(scopeId, read.environment, read.node);
+				return boundary !== undefined && this.#owningFunction(boundary.node) === value.environment.scopeNode ? boundary : undefined;
+			}
+			#hasActivation(environment, activation) {
+				for (let current = environment; current; current = current.parent) {
+					if (--this.#remainingEvaluations < 0) {
+						this.truncated = true;
+						return false;
+					}
+					if (current.activation === activation) return true;
+				}
+				return false;
+			}
+			#namespaceCallerBoundary(value, environment, activation) {
+				for (let current = environment; current.caller !== undefined; current = current.caller) {
+					if (--this.#remainingEvaluations < 0) {
+						this.truncated = true;
+						return undefined;
+					}
+					const point = current.point;
+					if (point !== undefined && this.#owningFunction(point) === value.environment.scopeNode && this.#hasActivation(current.caller, activation)) return {
+						node: point,
+						edge: "start"
+					};
+				}
+				return undefined;
+			}
+			#owningFunction(node) {
+				let current = node;
+				while (current !== undefined && !t.isFunction(current)) current = this.state.parentsByNode.get(current);
+				return current;
+			}
+			#namespaceWrites(value, read, selectedKey) {
+				const writes = this.#writes.get(value.bindingId) ?? [];
+				const completedAt = value.environment.completedAt;
+				const boundary = read === undefined ? undefined : this.#namespaceReadBoundary(value, read);
+				if (this.#remainingEvaluations <= 0) {
+					this.truncated = true;
+					return undefined;
+				}
+				const sourcePoint = boundary?.node[boundary.edge];
+				if (boundary !== undefined && sourcePoint == null) return undefined;
+				if (completedAt !== undefined && completedAt.end == null) return undefined;
+				if (sourcePoint == null && completedAt === undefined) return read === undefined ? writes : undefined;
+				const point = Math.min(sourcePoint ?? Infinity, completedAt?.end ?? Infinity);
+				const commonThrough = value.environment.commonThrough?.end;
+				const changed = new Set();
+				if (commonThrough != null) {
+					if (writes.length > this.#remainingEvaluations) {
+						this.#remainingEvaluations = 0;
+						this.truncated = true;
+						return undefined;
+					}
+					this.#remainingEvaluations -= writes.length;
+					for (const write of writes) {
+						if (write.site.end == null) return undefined;
+						if (write.site.end > completedAt.end && write.site.end <= commonThrough) {
+							if (write.path.length === 0) return [];
+							changed.add(write.path[0]);
+						}
+					}
+				}
+				return writes.filter((write) => write.site.end != null && write.site.end <= point && (changed.size === 0 || (write.path.length > 0 ? !changed.has(write.path[0]) : selectedKey !== undefined && !changed.has(selectedKey))));
+			}
+			#completeNamespace(value, point, commonThrough) {
+				const values = new Map(value.environment.values);
+				const environment = {
+					...value.environment,
+					values,
+					completedAt: point,
+					...commonThrough === undefined ? {} : { commonThrough }
+				};
+				const completed = {
+					...value,
 					environment
 				};
+				for (const [bindingId, slot] of value.environment.values) {
+					if (slot === value) values.set(bindingId, completed);
+					else if (this.#moduleBindings.has(bindingId) && this.#exportAliases.get(bindingId) === value.bindingId && slot.kind === "record" && slot.values.get("exports") === value) {
+						values.set(bindingId, {
+							...slot,
+							values: new Map(slot.values).set("exports", completed)
+						});
+					}
+				}
+				return completed;
 			}
-			#moduleCompletionPoint(factory) {
-				let earliestReturn;
-				traverseJavaScriptAst(factory.body, {
-					skip: (node) => t.isFunction(node) || t.isClass(node),
-					enter: (node) => {
-						if (t.isReturnStatement(node) && (earliestReturn === undefined || (node.start ?? Infinity) < (earliestReturn.start ?? Infinity))) earliestReturn = node;
+			#moduleExports(value) {
+				const factory = this.#namespaceOwners.get(value.bindingId);
+				if (factory === undefined) return value;
+				const cached = this.#completedModules.get(value.environment);
+				if (cached !== undefined) return cached;
+				if (this.#activeFunctions.has(factory)) return symbolicUnknown("recursive module completion");
+				this.#activeFunctions.add(factory);
+				try {
+					const flow = this.#returnFlow(t.isBlockStatement(factory.body) ? factory.body.body : [], value.environment, (statement) => this.#completeNamespace(value, statement));
+					const completed = symbolicUnion([...flow.values, ...flow.fallsThrough ? [this.#withConditions(this.#completeNamespace(value, factory.body), flow)] : []]);
+					const variants = symbolicVariants(completed);
+					if (variants.length > 1 && variants.every((variant) => variant.kind === "namespace" && variant.environment.completedAt?.end != null && !variant.conditionUnresolved)) {
+						if (variants.length > this.#remainingEvaluations) {
+							this.#remainingEvaluations = 0;
+							this.truncated = true;
+						} else {
+							this.#remainingEvaluations -= variants.length;
+							const exits = variants;
+							let first = exits[0].environment.completedAt;
+							let last = first;
+							for (const exit of exits) {
+								const point = exit.environment.completedAt;
+								if (point.end < first.end) first = point;
+								if (point.end > last.end) last = point;
+							}
+							const common = this.#completeNamespace(value, first, last);
+							const group = {
+								members: new Set(variants),
+								common
+							};
+							for (const variant of variants) this.#completionGroups.set(variant, group);
+						}
 					}
-				});
-				return earliestReturn ?? factory.body;
+					this.#completedModules.set(value.environment, completed);
+					return completed;
+				} finally {
+					this.#activeFunctions.delete(factory);
+				}
 			}
 			#call(node, env) {
 				const callee = this.evaluate(node.callee, env);
@@ -651,16 +889,7 @@ function init_javascriptSymbolicBindings() {
 					if (value.kind === "loader") {
 						const key = args[0];
 						const loaded = key?.kind === "literal" ? value.modules.get(String(key.value)) ?? symbolicUnknown("missing module") : symbolicUnknown("dynamic module");
-						if (loaded.kind === "namespace") {
-							const factory = this.#namespaceOwners.get(loaded.bindingId);
-							result = factory === undefined ? loaded : {
-								...loaded,
-								environment: {
-									...loaded.environment,
-									completedAt: this.#moduleCompletionPoint(factory)
-								}
-							};
-						} else result = loaded;
+						result = loaded.kind === "namespace" ? this.#moduleExports(loaded) : loaded;
 					} else if (value.kind === "external" && value.path.join(".") === "require") {
 						const spec = args[0];
 						result = spec?.kind === "literal" && typeof spec.value === "string" ? {
@@ -669,44 +898,46 @@ function init_javascriptSymbolicBindings() {
 						} : symbolicUnknown("dynamic require");
 					} else if (value.kind !== "function" || this.#activeFunctions.has(value.node)) {
 						result = symbolicUnknown("unresolved or recursive call");
+					} else if (this.callBody(value) === undefined) {
+						result = { kind: "iterator" };
 					} else {
 						this.#activeFunctions.add(value.node);
 						try {
-							const bound = this.bind(value, args, node);
+							const bound = this.bind(value, args, node, env);
 							const returned = t.isBlockStatement(value.node.body) ? this.#returns(value.node.body.body, bound) : this.evaluate(value.node.body, bound);
-							result = symbolicUnion(symbolicVariants(returned).map((v) => v.kind === "function" ? {
-								...this.#completeReturnedFunction(v, bound, v.returnPoint ?? value.node.body),
-								origins: [
-									...value.origins,
-									node,
-									...v.origins
-								]
-							} : v));
+							const completed = this.#completeReturnedValue(returned, bound, value.node.body, [...value.origins, node]);
+							result = value.node.async ? {
+								kind: "promise",
+								value: this.#awaited(completed)
+							} : completed;
 						} finally {
 							this.#activeFunctions.delete(value.node);
 						}
 					}
-					for (const condition of value.conditions ?? []) result = symbolicCondition(result, condition);
-					if (value.conditionUnresolved) result = symbolicConditionsUnresolved(result);
-					return result;
+					return this.#withConditions(result, value);
 				}));
 			}
 			#returns(statements, env) {
-				const flow = this.#returnFlow(statements, env);
-				return symbolicUnion([...flow.values, ...flow.fallsThrough ? [{
+				const flow = this.#returnFlow(statements, env, (statement) => {
+					const value = this.evaluate(statement.argument, env);
+					return symbolicUnion(symbolicVariants(value).map((variant) => variant.kind === "function" || variant.kind === "promise" ? {
+						...variant,
+						returnPoint: statement
+					} : variant));
+				});
+				return symbolicUnion([...flow.values, ...flow.fallsThrough ? [this.#withConditions({
 					kind: "literal",
 					value: undefined
-				}] : []]);
+				}, flow)] : []]);
 			}
-			#returnFlow(statements, env, depth = 0) {
+			#returnFlow(statements, env, returnedValue, depth = 0) {
 				const possible = [];
 				let unresolvedFallthrough = false;
 				const continuationConditions = [];
-				const guardCurrentPath = (value) => {
-					let guarded = value;
-					for (const condition of continuationConditions) guarded = symbolicCondition(guarded, condition);
-					return unresolvedFallthrough ? symbolicConditionsUnresolved(guarded) : guarded;
-				};
+				const guardCurrentPath = (value) => this.#withConditions(value, {
+					conditions: continuationConditions,
+					...unresolvedFallthrough ? { conditionUnresolved: true } : {}
+				});
 				for (const statement of statements) {
 					if (--this.#remainingEvaluations < 0 || depth >= 128) {
 						this.truncated = true;
@@ -720,28 +951,25 @@ function init_javascriptSymbolicBindings() {
 						fallsThrough: false
 					};
 					if (t.isReturnStatement(statement)) {
-						const value = this.evaluate(statement.argument, env);
-						const returned = symbolicUnion(symbolicVariants(value).map((variant) => variant.kind === "function" ? {
-							...variant,
-							returnPoint: statement
-						} : variant));
 						return {
-							values: [...possible, guardCurrentPath(returned)],
+							values: [...possible, guardCurrentPath(returnedValue(statement))],
 							fallsThrough: false
 						};
 					}
 					if (t.isBlockStatement(statement)) {
-						const flow = this.#returnFlow(statement.body, env, depth + 1);
+						const flow = this.#returnFlow(statement.body, env, returnedValue, depth + 1);
 						possible.push(...flow.values.map(guardCurrentPath));
 						if (!flow.fallsThrough) return {
 							values: possible,
 							fallsThrough: false
 						};
+						continuationConditions.push(...flow.conditions ?? []);
+						unresolvedFallthrough ||= flow.conditionUnresolved === true;
 					}
 					if (t.isIfStatement(statement)) {
 						const truth = symbolicTruth(this.evaluate(statement.test, env));
 						const branches = truth === undefined ? [statement.consequent, statement.alternate] : [truth ? statement.consequent : statement.alternate];
-						const flows = branches.map((branch) => this.#returnFlow(branch ? [branch] : [], env, depth + 1));
+						const flows = branches.map((branch) => this.#returnFlow(branch ? [branch] : [], env, returnedValue, depth + 1));
 						possible.push(...flows.flatMap((flow, index) => flow.values.map((value) => {
 							const guarded = guardCurrentPath(value);
 							return truth === undefined ? symbolicCondition(guarded, {
@@ -753,7 +981,10 @@ function init_javascriptSymbolicBindings() {
 							values: possible,
 							fallsThrough: false
 						};
-						if (truth === undefined) {
+						if (truth !== undefined) {
+							continuationConditions.push(...flows[0]?.conditions ?? []);
+							unresolvedFallthrough ||= flows[0]?.conditionUnresolved === true;
+						} else {
 							const fallthrough = flows.flatMap((flow, index) => flow.fallsThrough ? [{
 								flow,
 								index
@@ -765,7 +996,7 @@ function init_javascriptSymbolicBindings() {
 							else if (fallthrough.length > 0 && (fallthrough.length < flows.length || fallthrough.some(({ flow }) => flow.values.length > 0))) unresolvedFallthrough = true;
 						}
 					}
-					if (t.isWhileStatement(statement) || t.isDoWhileStatement(statement) || t.isForStatement(statement) || t.isForInStatement(statement) || t.isForOfStatement(statement) || t.isSwitchStatement(statement) || t.isTryStatement(statement)) {
+					if (t.isLoop(statement) || t.isSwitchStatement(statement) || t.isTryStatement(statement) || t.isLabeledStatement(statement) || t.isWithStatement(statement)) {
 						if (containsOwnedReturn(statement)) {
 							possible.push(symbolicUnknown(`unsupported return control flow: ${statement.type}`));
 							unresolvedFallthrough = true;
@@ -774,7 +1005,9 @@ function init_javascriptSymbolicBindings() {
 				}
 				return {
 					values: possible,
-					fallsThrough: true
+					fallsThrough: true,
+					...continuationConditions.length ? { conditions: continuationConditions } : {},
+					...unresolvedFallthrough ? { conditionUnresolved: true } : {}
 				};
 			}
 			#indexBootstrap(call) {
@@ -797,6 +1030,7 @@ function init_javascriptSymbolicBindings() {
 					const values = new Map();
 					const environment = {
 						values,
+						activation: {},
 						point: factory.body,
 						scopeNode: factory,
 						...this.state.scopeByNode.get(factory)?.scopeId === undefined ? {} : { scopeId: this.state.scopeByNode.get(factory).scopeId }
@@ -865,7 +1099,7 @@ function init_javascriptSymbolicBindings() {
 			#indexWriteSite(target, site) {
 				const direct = unwrapJavaScriptExpression(target).node;
 				if ((t.isIdentifier(direct) || t.isMemberExpression(direct)) && !t.isForOfStatement(site) && !t.isForInStatement(site)) {
-					this.#indexWrite(direct, t.isAssignmentExpression(site) ? site.right : site, site);
+					this.#indexWrite(direct, site, site);
 					return;
 				}
 				for (const leaf of semanticWriteTargets(target)) this.#indexWrite(leaf, site, site, false);
@@ -904,10 +1138,6 @@ function init_javascriptSymbolicBindings() {
 						}
 					}
 				}
-				if (alias && selected.length === 0) {
-					this.#replacements.set(key, value);
-					return;
-				}
 				const writes = this.#writes.get(key) ?? [];
 				writes.push({
 					path: selected,
@@ -954,7 +1184,7 @@ function handlerKind(node) {
 	if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) return "member-expression";
 	return "dynamic-expression";
 }
-var electronCalleePath, electronStaticValue, boundedExpression, objectProperty, collectContextBridgeMembers, collectMembersAt, literalValue;
+var electronCalleePath, electronStaticValue, boundedExpression, collectContextBridgeMembers, collectMembersAt, literalValue;
 function init_electronStaticAnalysisValues() {
 	return (init_electronStaticAnalysisValues = __esmMin((() => {
 		init_unicodeCodePointOrder();
@@ -989,21 +1219,6 @@ function init_electronStaticAnalysisValues() {
 			const expression = sourceSlice(source, node).trim();
 			return expression === "" ? `[${node.type}]` : expression;
 		};
-		objectProperty = (object, name) => {
-			if (object === undefined) return { status: "missing" };
-			if (!t.isObjectExpression(object)) return { status: "dynamic" };
-			for (const property of object.properties.toReversed()) {
-				if (t.isSpreadElement(property)) return { status: "dynamic" };
-				const key = semanticStaticPropertyName(property.key, property.computed);
-				if (key === "" && !t.isStringLiteral(property.key)) return { status: "dynamic" };
-				if (key !== name) continue;
-				return t.isObjectProperty(property) ? {
-					status: "explicit",
-					property
-				} : { status: "dynamic" };
-			}
-			return { status: "missing" };
-		};
 		collectContextBridgeMembers = (node) => {
 			if (node === null || node === undefined) return {
 				status: "missing",
@@ -1349,7 +1564,7 @@ function init_electronStaticAnalysisIpc() {
 
 //#endregion
 //#region dist/domain/javascript/electronWrappedCallPaths.js
-var callLabel, collectElectronWrappedCallPaths;
+var callLabel, ipcEndpointKey, ipcInvocationKey, indexIpcFinding, collectElectronWrappedCallPaths;
 function init_electronWrappedCallPaths() {
 	return (init_electronWrappedCallPaths = __esmMin((() => {
 		init_javascriptAstValues();
@@ -1363,11 +1578,32 @@ function init_electronWrappedCallPaths() {
 		init_javascriptSymbolicControlFlow();
 		init_unicodeCodePointOrder();
 		callLabel = (node) => t.isSequenceExpression(node) ? callLabel(node.expressions.at(-1) ?? node) : calleeName(node) || "local call";
+		ipcEndpointKey = (value) => JSON.stringify([
+			value.side,
+			value.operation,
+			value.channel,
+			value.location
+		]);
+		ipcInvocationKey = (location) => String(JSON.stringify(location));
+		indexIpcFinding = (index, value) => {
+			const key = ipcEndpointKey(value);
+			let facts = index.get(key);
+			if (facts === undefined) {
+				facts = {
+					observedTransmission: false,
+					invocations: new Set()
+				};
+				index.set(key, facts);
+			}
+			facts.observedTransmission ||= value.resolution_basis === undefined && (value.mode === "send" || value.mode === "invoke");
+			facts.invocations.add(ipcInvocationKey(value.invocation_location));
+		};
 		collectElectronWrappedCallPaths = (program, state, source, accumulator, identity) => {
 			let remainingVisits = 1e6;
 			const resolver = new JavaScriptSymbolicBindings(state, program, identity);
 			const paths = [];
 			const seen = new Set();
+			const unconditionalRegistrations = new Set();
 			const step = (node, kind, label) => {
 				const module = accumulator.moduleRangeIndex.find(node.start);
 				return {
@@ -1425,6 +1661,13 @@ function init_electronWrappedCallPaths() {
 				}
 				return value.conditions?.reduce((current, branch) => condition(current, branch.node, branch.positive), context) ?? context;
 			};
+			let ipcByEndpoint;
+			const ipcAtEndpoint = () => {
+				if (ipcByEndpoint !== undefined) return ipcByEndpoint;
+				ipcByEndpoint = new Map();
+				for (const { value } of accumulator.ipc) indexIpcFinding(ipcByEndpoint, value);
+				return ipcByEndpoint;
+			};
 			const hasConditions = (value) => symbolicVariants(value).some((variant) => variant.conditions?.length);
 			function* bridgeMemberFunctions(value, segments = [], active = new Set()) {
 				if (active.has(value)) return;
@@ -1489,14 +1732,15 @@ function init_electronWrappedCallPaths() {
 				seen.add(key);
 				paths.push(path);
 			};
-			const functionBody = (fn, args, context, invocationNode) => {
-				if (context.active.has(fn.node)) return;
+			const functionBody = (fn, args, context, invocationNode, caller) => {
+				const body = resolver.callBody(fn);
+				if (body === undefined || context.active.has(fn.node)) return;
 				if (fn.conditionUnresolved === true) {
 					accumulator.unknownFindings += 1;
 					return;
 				}
 				const name = (t.isFunctionExpression(fn.node) || t.isFunctionDeclaration(fn.node)) && fn.node.id ? fn.node.id.name : "closure";
-				walk(fn.node.body, resolver.bind(fn, args, invocationNode), {
+				walk(body, resolver.bind(fn, args, invocationNode, caller), {
 					...context,
 					steps: [
 						...context.steps,
@@ -1557,18 +1801,39 @@ function init_electronWrappedCallPaths() {
 					handler_location: null,
 					...findingContext
 				};
-				const duplicate = accumulator.ipc.some(({ value }) => value.side === finding.side && value.operation === finding.operation && value.channel === channel && JSON.stringify(value.location) === JSON.stringify(location) && (value.resolution_basis === undefined && (value.mode === "send" || value.mode === "invoke") || JSON.stringify(value.invocation_location) === JSON.stringify(invocationLocation)));
+				const recorded = ipcAtEndpoint().get(ipcEndpointKey(finding));
+				const duplicate = recorded !== undefined && (recorded.observedTransmission || recorded.invocations.has(ipcInvocationKey(invocationLocation)));
 				const findingGuarded = context.conditions.length > 0 || hasConditions(first) || guardedDispatch;
+				const registrationKey = descriptor.side === "main" ? JSON.stringify([
+					endpoint,
+					channel,
+					location,
+					range$1(context.entryNode),
+					context.entryKind,
+					context.entry,
+					context.entryPath,
+					context.steps
+				]) : undefined;
+				if (!findingGuarded && registrationKey !== undefined) unconditionalRegistrations.add(registrationKey);
 				if (!duplicate && !findingGuarded) {
+					const value = {
+						...finding,
+						resolution_basis: "wrapper-substitution"
+					};
 					accumulator.ipc.push({
 						offset: node.start ?? -1,
-						value: {
-							...finding,
-							resolution_basis: "wrapper-substitution"
-						}
+						value
 					});
+					indexIpcFinding(ipcAtEndpoint(), value);
 					if (descriptor.mode !== "send" && descriptor.mode !== "invoke" && !fn) accumulator.unknownFindings += 1;
-				} else if (findingGuarded) accumulator.unknownFindings += 1;
+				} else if (findingGuarded && (registrationKey === undefined || !unconditionalRegistrations.has(registrationKey))) {
+					accumulator.unknownFindings += 1;
+					if (descriptor.side === "main") emit({
+						...channelContext,
+						entryKind: channelContext.entryKind ?? "ipc-handler",
+						entry: channelContext.entry || channel
+					}, node, endpoint, channel);
+				}
 				if (descriptor.mode === "send" || descriptor.mode === "invoke") {
 					emit(channelContext, node, endpoint, channel);
 					return;
@@ -1652,7 +1917,7 @@ function init_electronWrappedCallPaths() {
 						functionBody(callee, args, {
 							...branchContext,
 							steps: [...branchContext.steps, step(node, "call", callLabel(node.callee))]
-						}, node);
+						}, node, env);
 					} else if (callee.kind === "external") {
 						const path = callee.path;
 						const endpoint = path.join(".");
@@ -1742,9 +2007,67 @@ function init_electronWrappedCallPaths() {
 	})))();
 }
 
+//#endregion
+//#region dist/domain/javascript/electronStaticOptionObjects.js
+var optionObjectCandidate, hasElectronOptionObjectCandidate, resolveElectronOptionObject;
+function init_electronStaticOptionObjects() {
+	return (init_electronStaticOptionObjects = __esmMin((() => {
+		init_javascriptAstValues();
+		init_javascriptSemanticMutationInitializers();
+		init_javascriptSemanticState();
+		optionObjectCandidate = (input, index) => {
+			if (input === undefined) return undefined;
+			let node = unwrapJavaScriptExpression(input).node;
+			const seen = new Set();
+			const references = [];
+			while (t.isIdentifier(node)) {
+				if (seen.has(node)) return undefined;
+				seen.add(node);
+				const binding = index.bindingForReferenceAt(node);
+				if (binding === undefined) return undefined;
+				const initializer = semanticStableInitializer(binding, index.bindings);
+				if (binding.mutable || binding.declarationKinds.size !== 1 || !binding.declarationKinds.has("const") || initializer === undefined || initializer.projection.length !== 0 || !semanticBindingAtRead(binding, node, index.bindings.parentsByNode).hasDefiniteInitializer) return undefined;
+				references.push(node);
+				node = unwrapJavaScriptExpression(initializer.node).node;
+			}
+			return t.isObjectExpression(node) ? {
+				object: node,
+				references
+			} : undefined;
+		};
+		hasElectronOptionObjectCandidate = (input, index) => optionObjectCandidate(input, index) !== undefined;
+		resolveElectronOptionObject = (input, site, index, propertyPath = []) => {
+			const candidate = optionObjectCandidate(input, index);
+			if (candidate === undefined) return undefined;
+			for (const reference of candidate.references) {
+				if (index.referenceMayHaveChangedAt(site, reference, propertyPath)) return undefined;
+			}
+			return candidate.object;
+		};
+	})))();
+}
+
 //#endregion
 //#region dist/domain/javascript/electronStaticAnalysisBrowser.js
-var inspectElectronBrowserNode, inspectBrowserWindow, collectWindowOptions, collectWebPreferences, inspectContextBridge, inspectUtilityProcess;
+/** Batch deferred options after the shared mutation index can yield safely. */
+function* finishElectronBrowserWindowsSteps(context, index) {
+	const pending = context.accumulator.pendingBrowserWindows;
+	if (pending.length === 0) return;
+	if (pending.some((node) => {
+		const argument = argumentNode(node.arguments[0]);
+		const options = argument && unwrapJavaScriptExpression(argument).node;
+		if (t.isIdentifier(options)) return hasElectronOptionObjectCandidate(options, index);
+		const lookup = staticObjectProperty(options, "webPreferences");
+		return lookup.status === "explicit" && hasElectronOptionObjectCandidate(lookup.property.value, index);
+	})) yield* index.indexMemberMutationFactsSteps();
+	for (const node of pending) {
+		inspectBrowserWindow(node, context, index);
+		yield;
+	}
+	context.accumulator.browserWindows.sort((left, right) => left.offset - right.offset);
+	pending.length = 0;
+}
+var inspectElectronBrowserNode, needsConstantOptions, inspectBrowserWindow, collectWindowOptions, collectWebPreferences, inspectContextBridge, inspectUtilityProcess;
 function init_electronStaticAnalysisBrowser() {
 	return (init_electronStaticAnalysisBrowser = __esmMin((() => {
 		init_javascriptContextBridgeExposure();
@@ -1753,22 +2076,41 @@ function init_electronStaticAnalysisBrowser() {
 		init_javascriptStaticAnalysisFindings();
 		init_javascriptStaticAnalysisHelpers();
 		init_javascriptAstValues();
+		init_electronStaticOptionObjects();
 		inspectElectronBrowserNode = (node, context) => {
-			if (t.isNewExpression(node)) inspectBrowserWindow(node, context);
+			if (t.isNewExpression(node)) {
+				const path = electronCalleePath(node.callee, context);
+				if (path?.length === 1 && path[0] === "BrowserWindow") {
+					if (needsConstantOptions(node)) context.accumulator.pendingBrowserWindows.push(node);
+					else inspectBrowserWindow(node, context);
+				}
+			}
 			if (!t.isCallExpression(node) && !t.isOptionalCallExpression(node)) return;
 			inspectContextBridge(node, context);
 			inspectUtilityProcess(node, context);
 		};
-		inspectBrowserWindow = (node, context) => {
-			const path = electronCalleePath(node.callee, context);
-			if (path?.length !== 1 || path[0] !== "BrowserWindow") return;
-			const options = argumentNode(node.arguments[0]);
-			const collected = collectWindowOptions(context.source, options);
+		needsConstantOptions = (node) => {
+			const argument = argumentNode(node.arguments[0]);
+			const options = argument && unwrapJavaScriptExpression(argument).node;
+			if (t.isIdentifier(options)) return true;
+			const lookup = staticObjectProperty(options, "webPreferences");
+			return lookup.status === "explicit" && t.isIdentifier(unwrapJavaScriptExpression(lookup.property.value).node);
+		};
+		inspectBrowserWindow = (node, context, index) => {
+			const argument = argumentNode(node.arguments[0]);
+			const options = argument === undefined ? undefined : unwrapJavaScriptExpression(argument).node;
+			const resolvedOptions = (index && resolveElectronOptionObject(options, node, index, ["webPreferences"])) ?? options;
+			const lookup = staticObjectProperty(resolvedOptions, "webPreferences");
+			const declaredPreferences = lookup.status === "explicit" ? unwrapJavaScriptExpression(lookup.property.value).node : undefined;
+			const resolvedPreferences = (index && resolveElectronOptionObject(declaredPreferences, node, index)) ?? declaredPreferences;
+			const resolutionSources = [...resolvedOptions !== options && resolvedOptions !== undefined ? [range$1(resolvedOptions)] : [], ...resolvedPreferences !== declaredPreferences && resolvedPreferences !== undefined ? [range$1(resolvedPreferences)] : []];
+			const collected = collectWindowOptions(context.source, lookup.status, resolvedPreferences);
 			context.accumulator.unknownFindings += collected.unknown;
 			const finding = {
-				options_status: options === undefined ? "missing" : t.isObjectExpression(options) ? "object-literal" : "dynamic",
+				options_status: resolvedOptions === undefined ? "missing" : t.isObjectExpression(resolvedOptions) ? "object-literal" : "dynamic",
 				web_preferences_status: collected.status,
 				web_preferences: collected.preferences,
+				...resolutionSources.length > 0 ? { resolution_sources: resolutionSources } : {},
 				...collected.preload,
 				module_key: null,
 				location: range$1(node)
@@ -1780,23 +2122,22 @@ function init_electronStaticAnalysisBrowser() {
 				value: finding
 			});
 		};
-		collectWindowOptions = (source, options) => {
-			const lookup = objectProperty(options, "webPreferences");
-			if (lookup.status !== "explicit" || !t.isObjectExpression(lookup.property.value)) return {
-				status: lookup.status === "missing" ? "missing" : "dynamic",
+		collectWindowOptions = (source, lookupStatus, preferences) => {
+			if (lookupStatus !== "explicit" || !t.isObjectExpression(preferences)) return {
+				status: lookupStatus === "missing" ? "missing" : "dynamic",
 				preferences: [],
 				preload: {
 					preload_path: null,
 					preload_resolution_context: null
 				},
-				unknown: lookup.status === "missing" ? 0 : 1
+				unknown: lookupStatus === "missing" ? 0 : 1
 			};
-			return collectWebPreferences(source, lookup.property.value);
+			return collectWebPreferences(source, preferences);
 		};
 		collectWebPreferences = (source, object) => {
 			const preferences = [];
 			let unknown = 0;
-			const effectivePreload = objectProperty(object, "preload");
+			const effectivePreload = staticObjectProperty(object, "preload");
 			const preloadPath = effectivePreload.status === "explicit" ? staticPath(effectivePreload.property.value) : undefined;
 			const preload = effectivePreload.status === "explicit" && preloadPath !== undefined ? {
 				preload_path: preloadPath,
@@ -1895,7 +2236,7 @@ function init_electronStaticAnalysisBrowser() {
 			const moduleNode = argumentNode(node.arguments[0]);
 			const modulePath = moduleNode === undefined ? undefined : staticPath(moduleNode);
 			const options = argumentNode(node.arguments[2]);
-			const serviceNameProperty = objectProperty(options, "serviceName");
+			const serviceNameProperty = staticObjectProperty(options, "serviceName");
 			const serviceName = serviceNameProperty.status === "explicit" ? staticPath(serviceNameProperty.property.value) : undefined;
 			if (serviceNameProperty.status !== "missing" && serviceName === undefined) context.accumulator.unknownFindings += 1;
 			if (modulePath === undefined) context.accumulator.unknownFindings += 1;
@@ -2176,9 +2517,20 @@ function init_electronStaticAnalysis() {
 
 //#endregion
 //#region dist/domain/javascript/javascriptStaticAnalysisCalls.js
-var inspectCall, workerUrlSpecifier, workerConstructorKind, noteMediaElementPreloads, requireCallSpecifier, chunkLoadSpecifier, vitePreloadDependencySpecifiers, isExplicitDefaultArgument, indexVitePreloadDependencyTable, inspectEndpointCall, inspectRpcNode, inspectRouteProperty, inspectRoleProperty, inspectStorageCall, addReference$1, addEndpoint$1, addSourceMapDirectives;
+/** Resolve deferred Source bodies after their document owners have been seen. */
+function* finishRpcScanSteps(context) {
+	for (const rpc of context.rpcScan.finish()) {
+		if (rpc !== undefined) addEndpoint$1(context, {
+			kind: "network",
+			...rpc
+		});
+		yield;
+	}
+}
+var inspectCall, moduleUrlSpecifier, workerConstructorKind, noteMediaElementPreloads, requireCallSpecifier, chunkLoadSpecifier, vitePreloadDependencySpecifiers, isExplicitDefaultArgument, indexVitePreloadDependencyTable, inspectEndpointCall, inspectLiteralEndpointCall, isNetworkRequestSpelling, isKnownNetworkRequest, finishPartialNetworkEndpoints, addPartialNetworkEndpoint, resolvedRequestTarget, requestInitializerPrecedesSite, requestReferenceNode, urlObjectRequestTarget, inspectRpcNode, inspectRouteProperty, inspectRoleProperty, inspectStorageCall, finishSqliteStorageCalls, addReference$1, addEndpoint$1, addSourceMapDirectives;
 function init_javascriptStaticAnalysisCalls() {
 	return (init_javascriptStaticAnalysisCalls = __esmMin((() => {
+		init_javascriptSemanticMapOperations();
 		init_javascriptSemanticTraversal();
 		init_artifactPathSyntax();
 		init_browserObservation();
@@ -2187,6 +2539,8 @@ function init_javascriptStaticAnalysisCalls() {
 		init_javascriptAstValues();
 		init_javascriptSemanticState();
 		init_javascriptSemanticAmbientWrites();
+		init_javascriptSemanticValues();
+		init_javascriptSemanticMutationInitializers();
 		init_javascriptSemanticRequireOrigin();
 		inspectCall = (source, node, context, bindings) => {
 			const { accumulator } = context;
@@ -2214,14 +2568,18 @@ function init_javascriptStaticAnalysisCalls() {
 			if (workerConstructor !== undefined || name === "Worker" || name.endsWith(".Worker")) addReference$1(context, {
 				node,
 				kind: "worker",
-				specifier: (workerConstructor === "node" ? undefined : first) ?? (workerConstructor === undefined || worker === undefined ? undefined : workerUrlSpecifier(worker, bindings))
+				specifier: workerConstructor === undefined || worker === undefined ? undefined : moduleUrlSpecifier(worker, bindings)
 			});
-			if (name === "serviceWorker.register" || name.endsWith(".serviceWorker.register")) addReference$1(context, {
+			if (!t.isNewExpression(node) && isUnmodifiedGlobalReference(node.callee, bindings, [
+				"navigator",
+				"serviceWorker",
+				"register"
+			])) addReference$1(context, {
 				node,
 				kind: "service-worker",
-				specifier: first
+				specifier: moduleUrlSpecifier(node, bindings)
 			});
-			inspectEndpointCall(node, name, first, context);
+			inspectEndpointCall(node, name, first, context, bindings);
 			inspectStorageCall(node, name, first, context);
 			if (first === "audio" || first === "video") noteMediaElementPreloads(node, accumulator);
 			if ((name === "loadFile" || name.endsWith(".loadFile")) && first !== undefined) addLocatedFinding(context, {
@@ -2251,8 +2609,8 @@ function init_javascriptStaticAnalysisCalls() {
 				}
 			});
 		};
-		workerUrlSpecifier = (worker, bindings) => {
-			const argumentExpression = argumentNode(worker.arguments[0]);
+		moduleUrlSpecifier = (call, bindings) => {
+			const argumentExpression = argumentNode(call.arguments[0]);
 			if (argumentExpression === undefined) return undefined;
 			const node = unwrapJavaScriptExpression(argumentExpression).node;
 			if (!t.isNewExpression(node)) return undefined;
@@ -2358,7 +2716,7 @@ function init_javascriptStaticAnalysisCalls() {
 			});
 			return escapedOrMutated ? dependencies.map(() => undefined) : dependencies;
 		};
-		inspectEndpointCall = (node, name, first, context) => {
+		inspectEndpointCall = (node, name, first, context, bindings) => {
 			const route = STATIC_ROUTE_CALL_NAMES.some((candidate) => name === candidate || name.endsWith(`.${candidate}`));
 			if (route && first !== undefined) addEndpoint$1(context, {
 				node,
@@ -2366,6 +2724,47 @@ function init_javascriptStaticAnalysisCalls() {
 				value: first,
 				mechanism: `call:${name}`
 			});
+			if (isKnownNetworkRequest(node, bindings)) {
+				const target = argumentNode(node.arguments[0]);
+				if (target === undefined) return;
+				const literal = stringValue(target);
+				if (literal !== undefined) {
+					addEndpoint$1(context, {
+						node,
+						kind: "network",
+						value: literal,
+						mechanism: `call:${name}`
+					});
+					return;
+				}
+				const reference = requestReferenceNode(target);
+				const unwrapped = unwrapJavaScriptExpression(reference).node;
+				if (t.isIdentifier(unwrapped) || t.isMemberExpression(unwrapped) || t.isOptionalMemberExpression(unwrapped)) {
+					context.accumulator.pendingNetworkCalls.push({
+						node,
+						name
+					});
+					return;
+				}
+				addPartialNetworkEndpoint(context, node, name, target);
+				return;
+			}
+			if (isNetworkRequestSpelling(name)) return;
+			if (first !== undefined && /(?:^|\.)(?:get|delete)$/u.test(name)) {
+				if (endpointArgument(name, node.arguments, node.callee, context.openReceiverFacts?.get(node.start ?? -1)) === undefined) return;
+				const mapLookup = isIntrinsicMapLookup(node, bindings);
+				if (mapLookup === true) return;
+				if (mapLookup === undefined) {
+					context.accumulator.pendingNetworkCalls.push({
+						node,
+						name
+					});
+					return;
+				}
+			}
+			inspectLiteralEndpointCall(node, name, context);
+		};
+		inspectLiteralEndpointCall = (node, name, context) => {
 			const receiverFact = context.openReceiverFacts?.get(node.start ?? -1);
 			const endpoint = endpointArgument(name, node.arguments, node.callee, receiverFact);
 			if (endpoint !== undefined) addEndpoint$1(context, {
@@ -2376,6 +2775,104 @@ function init_javascriptStaticAnalysisCalls() {
 				...endpoint.kind === "candidate" ? { interpretation: "candidate" } : {}
 			});
 		};
+		isNetworkRequestSpelling = (name) => name === "fetch" || name === "WebSocket" || name === "EventSource" || name === "sendBeacon" || name === "window.fetch" || name === "globalThis.fetch" || name === "self.fetch" || name === "navigator.sendBeacon";
+		isKnownNetworkRequest = (node, bindings) => {
+			if ((t.isCallExpression(node) || t.isOptionalCallExpression(node)) && isUnmodifiedGlobalReference(node.callee, bindings, "fetch")) return true;
+			if (t.isNewExpression(node) && (isUnmodifiedGlobalReference(node.callee, bindings, "WebSocket") || isUnmodifiedGlobalReference(node.callee, bindings, "EventSource"))) return true;
+			return (t.isCallExpression(node) || t.isOptionalCallExpression(node)) && isUnmodifiedGlobalReference(node.callee, bindings, ["navigator", "sendBeacon"]);
+		};
+		finishPartialNetworkEndpoints = (context, bindings, index) => {
+			for (const { node, name } of context.accumulator.pendingNetworkCalls) {
+				if (!isKnownNetworkRequest(node, bindings)) {
+					if (!isIntrinsicMapLookup(node, bindings, index)) inspectLiteralEndpointCall(node, name, context);
+					continue;
+				}
+				const target = argumentNode(node.arguments[0]);
+				if (target === undefined) continue;
+				const resolved = resolvedRequestTarget(target, node, bindings, index);
+				if (resolved !== undefined) addEndpoint$1(context, {
+					node,
+					kind: "network",
+					value: resolved,
+					mechanism: `call:${name}`
+				});
+				else addPartialNetworkEndpoint(context, node, name, target);
+			}
+			context.accumulator.pendingNetworkCalls.length = 0;
+			context.accumulator.endpoints.sort((left, right) => left.offset - right.offset);
+		};
+		addPartialNetworkEndpoint = (context, node, name, target) => addEndpoint$1(context, {
+			node,
+			kind: "network",
+			value: sourceSlice(context.source, target),
+			mechanism: `call:${name}`,
+			resolution: "partial"
+		});
+		resolvedRequestTarget = (node, site, bindings, index) => {
+			const reference = requestReferenceNode(node);
+			const expression = unwrapJavaScriptExpression(node).node;
+			const capture = reference === expression ? site : expression;
+			if (index.referenceMayHaveChangedAt(capture, reference)) return undefined;
+			if (!requestInitializerPrecedesSite(reference, capture, bindings, index)) return undefined;
+			const evaluated = evaluateSemanticExpression(node, bindings);
+			if (evaluated.status === "literal" && typeof evaluated.value === "string") return evaluated.value;
+			return urlObjectRequestTarget(node, capture, bindings, index);
+		};
+		requestInitializerPrecedesSite = (reference, site, bindings, index) => {
+			const binding = index.bindingForReferenceAt(reference);
+			const initializer = semanticStableInitializer(binding, bindings);
+			return initializer !== undefined && semanticTopLevelEffectFollowsCapture(initializer.node, site, bindings.parentsByNode);
+		};
+		requestReferenceNode = (node) => {
+			const target = unwrapJavaScriptExpression(node).node;
+			if ((t.isCallExpression(target) || t.isOptionalCallExpression(target)) && target.arguments.length === 0) {
+				const callee = unwrapJavaScriptExpression(target.callee).node;
+				if ((t.isMemberExpression(callee) || t.isOptionalMemberExpression(callee)) && semanticStaticPropertyName(callee.property, callee.computed) === "toString") return unwrapJavaScriptExpression(callee.object).node;
+			}
+			return target;
+		};
+		urlObjectRequestTarget = (node, site, bindings, index, seen = new Set()) => {
+			let target = unwrapJavaScriptExpression(node).node;
+			if ((t.isCallExpression(target) || t.isOptionalCallExpression(target)) && target.arguments.length === 0) {
+				const callee = unwrapJavaScriptExpression(target.callee).node;
+				if ((t.isMemberExpression(callee) || t.isOptionalMemberExpression(callee)) && semanticStaticPropertyName(callee.property, callee.computed) === "toString") target = unwrapJavaScriptExpression(callee.object).node;
+			}
+			if (!t.isIdentifier(target) || index.referenceMayHaveChangedAt(site, target)) return undefined;
+			const binding = index.bindingForReferenceAt(target);
+			if (binding === undefined || seen.has(binding.bindingId)) return undefined;
+			seen.add(binding.bindingId);
+			const stable = semanticStableInitializer(binding, bindings);
+			if (stable === undefined || !semanticTopLevelEffectFollowsCapture(stable.node, site, bindings.parentsByNode)) return undefined;
+			const initializer = stable.node;
+			if (initializer === undefined) return undefined;
+			const initialized = unwrapJavaScriptExpression(initializer).node;
+			if (t.isIdentifier(initialized)) return urlObjectRequestTarget(initialized, site, bindings, index, seen);
+			if (!t.isNewExpression(initialized)) return undefined;
+			if (!isUnmodifiedGlobalReference(initialized.callee, bindings, "URL")) return undefined;
+			if (["URL", "Object"].some((owner) => ["toString", "valueOf"].some((method) => bindings.ambientWrites.covers([
+				"global",
+				owner,
+				"prototype",
+				method
+			])))) return undefined;
+			const input = stringValue(initialized.arguments[0]);
+			if (input === undefined) return undefined;
+			if (initialized.arguments.length === 1) {
+				try {
+					return new URL(input).href;
+				} catch {
+					return undefined;
+				}
+			}
+			if (initialized.arguments.length !== 2) return undefined;
+			const base = stringValue(initialized.arguments[1]);
+			if (base === undefined) return undefined;
+			try {
+				return new URL(input, base).href;
+			} catch {
+				return undefined;
+			}
+		};
 		inspectRpcNode = (node, context) => {
 			const rpc = context.rpcScan.inspect(node);
 			if (rpc !== undefined) addEndpoint$1(context, {
@@ -2414,6 +2911,13 @@ function init_javascriptStaticAnalysisCalls() {
 			});
 		};
 		inspectStorageCall = (node, name, first, context) => {
+			if (name === "Database" || name.endsWith(".Database")) {
+				context.accumulator.pendingSqliteCalls.push({
+					node,
+					name
+				});
+				return;
+			}
 			const receiverFact = context.openReceiverFacts?.get(node.start ?? -1);
 			const storage = receiverFact === "local" || receiverFact === "local-indexed-db" || receiverFact === "local-cache-storage" ? undefined : receiverFact === "indexed-db" ? "indexed-db" : receiverFact === "cache-storage" ? "cache-storage" : storageKind(name);
 			if (storage === undefined) return;
@@ -2430,6 +2934,34 @@ function init_javascriptStaticAnalysisCalls() {
 				}
 			});
 		};
+		finishSqliteStorageCalls = (context, bindings, index) => {
+			for (const { node, name } of context.accumulator.pendingSqliteCalls) {
+				const callee = unwrapJavaScriptExpression(node.callee).node;
+				const provenance = evaluateSemanticExpressionProvenance(callee, bindings);
+				const changed = index.referenceMayHaveChangedAt(node, callee);
+				if (!changed && t.isIdentifier(callee) && provenance.status === "local") continue;
+				const origin = provenance.status === "module" ? provenance.origins[0] : undefined;
+				const path = origin?.importedPath;
+				const imported = origin?.resolutionMode !== "require";
+				const known = !changed && origin !== undefined && (origin.specifier === "better-sqlite3" && (origin.resolutionMode === "require" && path?.length === 0 || imported && path?.length === 1 && path[0] === "default") || origin.specifier === "sqlite3" && (path?.length === 1 && path[0] === "Database" || imported && path?.length === 2 && (path[0] === "default" || path[0] === "*") && path[1] === "Database"));
+				const first = stringValue(node.arguments[0]);
+				addLocatedFinding(context, {
+					collection: context.accumulator.storage,
+					key: `storage\0sqlite\0${known ? "api" : "candidate"}\0${first ?? ""}`,
+					node,
+					value: {
+						kind: "sqlite",
+						name: first ?? null,
+						mechanism: `call:${name}`,
+						...known ? {} : { interpretation: "candidate" },
+						module_key: null,
+						location: range$1(node)
+					}
+				});
+			}
+			context.accumulator.pendingSqliteCalls.length = 0;
+			context.accumulator.storage.sort((left, right) => left.offset - right.offset);
+		};
 		addReference$1 = (context, input) => {
 			const specifier = input.specifier ?? null;
 			const reference = specifier === null ? {
@@ -2453,13 +2985,14 @@ function init_javascriptStaticAnalysisCalls() {
 		};
 		addEndpoint$1 = (context, input) => addLocatedFinding(context, {
 			collection: context.accumulator.endpoints,
-			key: `endpoint\0${input.kind}\0${input.interpretation ?? "literal"}\0${input.value}`,
+			key: `endpoint\0${input.kind}\0${input.interpretation ?? "literal"}\0${input.resolution ?? "exact"}\0${input.value}`,
 			node: input.node,
 			value: {
 				kind: input.kind,
-				value: sanitizeEndpointCandidate(input.value),
+				value: input.resolution === "partial" ? input.value : sanitizeEndpointCandidate(input.value),
 				mechanism: input.mechanism,
 				...input.interpretation === undefined ? {} : { interpretation: input.interpretation },
+				...input.resolution === undefined ? {} : { resolution: input.resolution },
 				module_key: null,
 				location: range$1(input.node)
 			}
@@ -2534,22 +3067,38 @@ function init_javascriptAstFingerprint() {
 		semanticTokens = (node) => {
 			const tokens = [`node:${node.type}`];
 			if (t.isStringLiteral(node)) tokens.push(`string:${node.value}`);
+			else if (t.isBigIntLiteral(node)) tokens.push(`bigint:${String(node.value)}`);
+			else if (t.isDirectiveLiteral(node)) tokens.push(`directive:${node.value}`);
 			else if (t.isNumericLiteral(node)) tokens.push(`number:${String(node.value)}`);
 			else if (t.isBooleanLiteral(node)) tokens.push(`boolean:${String(node.value)}`);
 			else if (t.isRegExpLiteral(node)) tokens.push(`regexp:${node.pattern}/${node.flags}`);
 			else if (t.isTemplateElement(node)) tokens.push(`template:${JSON.stringify(node.value)}`);
-			else if (t.isBinaryExpression(node) || t.isLogicalExpression(node)) tokens.push(`operator:${node.operator}`);
-			else if (t.isUnaryExpression(node) || t.isUpdateExpression(node)) tokens.push(`operator:${node.operator}`);
+			else if (t.isBinaryExpression(node) || t.isLogicalExpression(node) || t.isUnaryExpression(node) || t.isUpdateExpression(node) || t.isAssignmentExpression(node)) tokens.push(`operator:${node.operator}`);
+			if (t.isUpdateExpression(node)) tokens.push(`prefix:${String(node.prefix)}`);
+			if (t.isVariableDeclaration(node)) tokens.push(`kind:${node.kind}`);
+			if (t.isFunction(node)) {
+				tokens.push(`async:${String(node.async)}`);
+				tokens.push(`generator:${String(node.generator)}`);
+			}
+			if (t.isObjectMethod(node)) tokens.push(`kind:${node.kind}`);
+			if (t.isClassMethod(node) || t.isClassPrivateMethod(node)) {
+				tokens.push(`kind:${node.kind}`);
+				tokens.push(`static:${String(node.static)}`);
+			}
+			if (t.isClassProperty(node) || t.isClassPrivateProperty(node) || t.isClassAccessorProperty(node)) tokens.push(`static:${String(node.static)}`);
 			if (t.isMemberExpression(node) || t.isOptionalMemberExpression(node)) {
 				tokens.push(`computed:${String(node.computed)}`);
 				if (!node.computed) {
-					const property = propertyName(node.property);
-					if (property !== "") tokens.push(`property:${property}`);
+					const property = semanticStaticPropertyKey(node.property, false);
+					if (property !== null) tokens.push(`property:${property}`);
 				}
 			}
-			if ((t.isObjectProperty(node) || t.isObjectMethod(node)) && !node.computed) {
-				const key = propertyName(node.key);
-				if (key !== "") tokens.push(`key:${key}`);
+			if (t.isObjectProperty(node) || t.isObjectMethod(node) || t.isClassMethod(node) || t.isClassProperty(node) || t.isClassAccessorProperty(node)) {
+				tokens.push(`computed:${String(node.computed)}`);
+				if (!node.computed) {
+					const key = semanticStaticPropertyKey(node.key, false);
+					if (key !== null) tokens.push(`key:${key}`);
+				}
 			}
 			return tokens;
 		};
@@ -2622,7 +3171,7 @@ function init_javascriptAstFingerprint() {
 var JAVASCRIPT_AST_FINGERPRINT_ALGORITHM;
 function init_javascriptStaticAnalysisTypes() {
 	return (init_javascriptStaticAnalysisTypes = __esmMin((() => {
-		JAVASCRIPT_AST_FINGERPRINT_ALGORITHM = "babel-ast-v2";
+		JAVASCRIPT_AST_FINGERPRINT_ALGORITHM = "babel-ast-v3";
 	})))();
 }
 /** Hard bounds applied to one AST-only JavaScript analysis. */
@@ -2865,11 +3414,14 @@ function init_javascriptStaticAnalysisState() {
 		createJavaScriptAnalysisAccumulator = (sourceLength) => ({
 			references: [],
 			endpoints: [],
+			pendingNetworkCalls: [],
 			storage: [],
+			pendingSqliteCalls: [],
 			roles: [],
 			sourceMaps: [],
 			registrations: [],
 			browserWindows: [],
+			pendingBrowserWindows: [],
 			contextBridgeApis: [],
 			ipc: [],
 			senderValidations: [],
@@ -2888,19 +3440,27 @@ function init_javascriptStaticAnalysisState() {
 //#endregion
 //#region dist/domain/javascript/javascriptStaticAnalysis.js
 /** Static analysis that yields during its source traversal; results are unchanged. */
-function* analyzeParsedJavaScriptStaticSourceSteps(source, file, openReceiverFacts) {
+function* analyzeParsedJavaScriptStaticSourceSteps(source, file) {
 	const accumulator = createJavaScriptAnalysisAccumulator(source.length);
-	const bindings = yield* indexJavaScriptBindingsSteps(file.program);
+	const index = yield* indexJavaScriptBindingsWithReceiversSteps(file.program);
+	const { bindings, receivers } = index;
+	yield* index.indexAmbientWritesSteps();
 	const electronIdentity = yield* indexJavaScriptElectronIdentitySteps(file.program, bindings);
-	const clientRoots = yield* classifyParsedJavaScriptRpcClientRootsSteps(file);
-	yield* traverseStaticSourceSteps(file, {
+	const findings = {
 		source,
 		accumulator,
 		vitePreloadDependencyTable: indexVitePreloadDependencyTable(file.program),
-		...openReceiverFacts === undefined ? {} : { openReceiverFacts },
+		openReceiverFacts: receivers.openReceivers,
 		electronBindings: electronIdentity.bindings,
-		rpcScan: createJavaScriptRpcScan(source, clientRoots)
-	}, bindings);
+		rpcScan: createJavaScriptRpcScan(source, receivers.rpcClientRoots, index)
+	};
+	yield* traverseStaticSourceSteps(file, findings, bindings);
+	yield* finishElectronBrowserWindowsSteps(findings, index);
+	if (accumulator.pendingNetworkCalls.length > 0 || accumulator.pendingSqliteCalls.length > 0) {
+		yield* index.indexMemberMutationFactsSteps();
+		finishPartialNetworkEndpoints(findings, bindings, index);
+		finishSqliteStorageCalls(findings, bindings, index);
+	}
 	accumulator.electronCallPaths = collectElectronWrappedCallPaths(file.program, bindings, source, accumulator, electronIdentity);
 	addSourceMapDirectives(source, file.comments ?? [], accumulator);
 	return finalizeStaticAnalysis(source, file, accumulator);
@@ -2911,6 +3471,7 @@ function* traverseStaticSourceSteps(file, findings, bindings) {
 		inspectNode(node, findings, bindings);
 		return undefined;
 	} });
+	yield* finishRpcScanSteps(findings);
 }
 var analyzeJavaScriptStaticSource, analyzeParsedJavaScriptStaticSource, finalizeStaticAnalysis, inspectNode;
 function init_javascriptStaticAnalysis() {
@@ -2919,6 +3480,7 @@ function init_javascriptStaticAnalysis() {
 		init_javascriptElectronMemberWrites();
 		init_javascriptSemanticTraversal();
 		init_electronStaticAnalysis();
+		init_electronStaticAnalysisBrowser();
 		init_javascriptStaticAnalysisHelpers();
 		init_javascriptStaticAnalysisCalls();
 		init_javascriptStaticAnalysisBundler();
@@ -2927,13 +3489,12 @@ function init_javascriptStaticAnalysis() {
 		init_javascriptSemanticAnalysis();
 		init_javascriptSourceParser();
 		init_javascriptRpcEndpoints();
-		init_javascriptSemanticProjection();
 		init_javascriptModuleDeclaration();
 		analyzeJavaScriptStaticSource = (source) => {
 			const file = parseJavaScriptSource(source);
-			return file === null ? failedJavaScriptStaticAnalysis() : analyzeParsedJavaScriptStaticSource(source, file, classifyParsedJavaScriptOpenReceivers(file));
+			return file === null ? failedJavaScriptStaticAnalysis() : analyzeParsedJavaScriptStaticSource(source, file);
 		};
-		analyzeParsedJavaScriptStaticSource = (source, file, openReceiverFacts) => completeSemanticSteps(analyzeParsedJavaScriptStaticSourceSteps(source, file, openReceiverFacts));
+		analyzeParsedJavaScriptStaticSource = (source, file) => completeSemanticSteps(analyzeParsedJavaScriptStaticSourceSteps(source, file));
 		finalizeStaticAnalysis = (source, file, accumulator) => {
 			const parserErrors = file.errors.length;
 			const limitations = [
@@ -3041,6 +3602,38 @@ function init_sourceMapContents() {
 	})))();
 }
 
+//#endregion
+//#region dist/application/javascript/JavaScriptArtifactAnalysisTypes.js
+var javascriptArtifactAnalysisScopes, isSkippedJavaScriptAnalysis;
+function init_JavaScriptArtifactAnalysisTypes() {
+	return (init_JavaScriptArtifactAnalysisTypes = __esmMin((() => {
+		javascriptArtifactAnalysisScopes = {
+			javascript: {
+				operation: "analyze-javascript-source",
+				authority: "ast-static-analysis"
+			},
+			"package-json": {
+				operation: "parse-package-json",
+				authority: "artifact-bytes"
+			},
+			json: {
+				operation: "parse-json-module",
+				authority: "artifact-bytes"
+			},
+			html: {
+				operation: "parse-html-script-references",
+				authority: "artifact-bytes"
+			},
+			"source-map": {
+				operation: "parse-local-source-map",
+				authority: "artifact-bytes"
+			},
+			"native-addon": null
+		};
+		isSkippedJavaScriptAnalysis = (entry) => entry.file.kind === "javascript" && entry.file.text.included && entry.javascript === null && entry.analysis_failure !== undefined;
+	})))();
+}
+
 //#endregion
 //#region dist/application/javascript/JavaScriptJsonModules.js
 var analyzeJavaScriptJsonModule;
@@ -3221,8 +3814,7 @@ function* analyzeArtifactFileSteps(file, context) {
 		state.parseFailures += 1;
 		return;
 	}
-	const openReceiverFacts = yield* classifyParsedJavaScriptOpenReceiversSteps(parsed);
-	const analysis = yield* analyzeParsedJavaScriptStaticSourceSteps(file.text.value, parsed, openReceiverFacts);
+	const analysis = yield* analyzeParsedJavaScriptStaticSourceSteps(file.text.value, parsed);
 	const staticFindings = findingCount(analysis);
 	yield;
 	const semantics = analysis.parse_status === "complete" || analysis.parse_status === "partial" ? yield* analyzeParsedJavaScriptSemanticsSteps(parsed, moduleResolutionModeForJavaScriptReference(file.path, "static-import")) : null;
@@ -3249,6 +3841,7 @@ function init_JavaScriptArtifactAnalysis() {
 		init_sourceMapContents();
 		init_sourceMapEnvelope();
 		init_javascriptStaticAnalysisHelpers();
+		init_JavaScriptArtifactAnalysisTypes();
 		init_JavaScriptJsonModules();
 		init_JavaScriptAnalysisControl();
 		init_htmlArtifactReferences();
@@ -3283,6 +3876,7 @@ function init_JavaScriptArtifactAnalysis() {
 			const selectedFileCount = fileSet.files.length - (fileSet.source_selection?.unselected_files ?? 0);
 			let selectedFileIndex = 0;
 			for (const file of fileSet.files) {
+				let analysisStarted = false;
 				try {
 					await setImmediate();
 					if (classifyOutsideAnalysisScope(file, state, projection)) {
@@ -3294,6 +3888,7 @@ function init_JavaScriptArtifactAnalysis() {
 					}
 					if (signal?.aborted === true) throw new AnalysisCancelledError("analyze_javascript_application");
 					await beforeFile(file, selectedFileIndex++, selectedFileCount);
+					analysisStarted = true;
 					if (file.kind !== "javascript" || !file.text.included) {
 						const steps = analyzeArtifactFileSteps(file, {
 							state,
@@ -3305,13 +3900,15 @@ function init_JavaScriptArtifactAnalysis() {
 						await completeJavaScriptAnalysisSteps(steps, signal);
 						continue;
 					}
-					const result = await worker.analyze(file, projection.remainingFileNodeBudget(), signal);
+					const result = await worker.analyze(file, projection.remainingFileCapacity(), signal);
 					const facts = result.ok ? result.value : result.error;
 					const applicationProjectionFailure = facts.applicationProjectionFailure;
 					if (facts.projection !== null) projection.adoptFileProjection(facts.projection);
 					const error = result.ok ? null : result.error.error;
 					const limits = error instanceof AnalysisResourceConstraintError ? error.reportedLimits : error instanceof AnalysisTimeoutError ? { worker_timeout_ms: error.timeoutMs } : null;
 					const failure = error === null ? undefined : {
+						scope: javascriptArtifactAnalysisScopes.javascript,
+						status: "interrupted",
 						reason: `${file.path}: ${error.message}`,
 						error: projectAnalysisError(error),
 						limits
@@ -3342,15 +3939,18 @@ function init_JavaScriptArtifactAnalysis() {
 					if (signal?.aborted !== true && !(cause instanceof AnalysisError)) throw cause;
 					interruption = signal?.aborted === true ? new AnalysisCancelledError("analyze_javascript_application") : cause instanceof AnalysisError ? cause : null;
 					if (interruption !== null) {
+						const scope = javascriptArtifactAnalysisScopes[file.kind];
 						state.files.push({
 							file,
 							javascript: null,
 							semantic: null,
-							analysis_failure: {
+							...scope === null ? {} : { analysis_failure: {
+								scope,
+								status: analysisStarted ? "interrupted" : "not-started",
 								reason: `${file.path}: ${interruption.message}`,
 								error: projectAnalysisError(interruption),
 								limits: null
-							}
+							} }
 						});
 						projection.recordUnavailableFile(file, interruption.message, null, "incomplete-module");
 					}
@@ -3364,16 +3964,27 @@ function init_JavaScriptArtifactAnalysis() {
 					error: projectAnalysisError(interruption),
 					limits: interruption instanceof AnalysisResourceConstraintError ? interruption.reportedLimits : interruption instanceof AnalysisTimeoutError ? { worker_timeout_ms: interruption.timeoutMs } : null
 				};
+				const failures = new Map();
 				for (const file of fileSet.files) {
 					if (analyzedPaths.has(file.path)) continue;
 					if (classifyOutsideAnalysisScope(file, state, projection)) continue;
+					const scope = javascriptArtifactAnalysisScopes[file.kind];
+					let unavailable = scope === null ? undefined : failures.get(scope);
+					if (scope !== null && unavailable === undefined) {
+						unavailable = {
+							...failure,
+							scope,
+							status: "not-started"
+						};
+						failures.set(scope, unavailable);
+					}
 					state.files.push({
 						file,
 						javascript: null,
 						semantic: null,
-						analysis_failure: failure
+						...unavailable === undefined ? {} : { analysis_failure: unavailable }
 					});
-					if (file.kind === "javascript") projection.recordUnavailableFile(file, failure.reason, failure.limits, interruption instanceof AnalysisResourceConstraintError || interruption instanceof AnalysisTimeoutError ? "resource-limit" : "incomplete-module");
+					projection.recordUnavailableFile(file, failure.reason, failure.limits, interruption instanceof AnalysisResourceConstraintError || interruption instanceof AnalysisTimeoutError ? "resource-limit" : "incomplete-module");
 				}
 			}
 			return {
@@ -3420,7 +4031,7 @@ function init_JavaScriptArtifactAnalysis() {
 				javascript: null,
 				semantic: null
 			});
-			if (file.kind === "javascript") projection?.recordUnavailableFile(file, "Source was not analyzed because it is outside the caller-selected source_paths.", null, "incomplete-module");
+			projection?.recordUnavailableFile(file, "Source was not analyzed because it is outside the caller-selected source_paths.", null, "incomplete-module");
 			return true;
 		};
 		addSourceMap = (file, context) => {
@@ -3609,9 +4220,9 @@ function init_javascriptApplicationProjectionResources() {
 var range, count, strings, pathContext, findingContext, withRuntime, staticValue, nullHandler, missingHandler, locatedHandler, ipcChannel, ipc, windowShape, bridgeShape, utilityShape, electron, referenceShape, javaScriptWorkerStaticAnalysisSchema, resourceLimit, primitive, property, semanticValue, origin, provenance, coverage, moduleLink, definitionKind, scope, binding, callable, javaScriptWorkerGraphRecordSchema, javaScriptWorkerProjectionHeaderSchema, javaScriptWorkerModuleRecordSchema, javaScriptWorkerModuleHeaderSchema;
 function init_JavaScriptAnalysisWorkerSchemas() {
 	return (init_JavaScriptAnalysisWorkerSchemas = __esmMin((() => {
+		init_javascriptSemanticGraphSchemas();
 		init_digests();
 		init_javascriptStaticAnalysisTypes();
-		init_javascriptSemanticGraphSchemas();
 		range = javaScriptSemanticNodeSchema.shape.identity.shape.source_range.unwrap();
 		count = z.number().int().nonnegative();
 		strings = z.array(z.string());
@@ -3741,7 +4352,8 @@ function init_JavaScriptAnalysisWorkerSchemas() {
 			web_preferences: z.array(z.strictObject({
 				name: z.string(),
 				value: staticValue
-			}))
+			})),
+			resolution_sources: z.array(range).exactOptional()
 		};
 		bridgeShape = {
 			resolution_basis: z.literal("wrapper-substitution").optional(),
@@ -3897,7 +4509,8 @@ function init_JavaScriptAnalysisWorkerSchemas() {
 				kind: z.enum(["route", "network"]),
 				value: z.string(),
 				mechanism: z.string(),
-				interpretation: z.literal("candidate").exactOptional()
+				interpretation: z.literal("candidate").exactOptional(),
+				resolution: z.literal("partial").exactOptional()
 			})),
 			storage: z.array(z.strictObject({
 				...findingContext,
@@ -3908,6 +4521,7 @@ function init_JavaScriptAnalysisWorkerSchemas() {
 					"cache-storage",
 					"sqlite"
 				]),
+				interpretation: z.literal("candidate").exactOptional(),
 				name: z.string().nullable(),
 				mechanism: z.string()
 			})),
@@ -3972,7 +4586,8 @@ function init_JavaScriptAnalysisWorkerSchemas() {
 		resourceLimit = z.enum([
 			"primitive-candidates",
 			"primitive-bytes",
-			"expression-depth"
+			"expression-depth",
+			"getter-expansion"
 		]);
 		primitive = z.union([
 			z.string(),
@@ -4201,8 +4816,9 @@ function init_JavaScriptAnalysisWorkerSchemas() {
 			})
 		]);
 		javaScriptWorkerProjectionHeaderSchema = z.strictObject({
+			omittedUnknownOccurrences: javaScriptSemanticUnknownOmissionsSchema.exactOptional(),
 			roots: z.array(javaScriptSemanticNodeSchema.shape.node_id),
-			truncated: z.boolean()
+			nodesTruncated: z.boolean()
 		});
 		javaScriptWorkerModuleRecordSchema = z.discriminatedUnion("kind", [
 			z.strictObject({
@@ -4256,7 +4872,11 @@ function* moduleTransferRecords(module) {
 		value
 	};
 }
-async function readJavaScriptAnalysisTransfer(path, descriptor, source, signal, retainGraph = true) {
+async function readJavaScriptAnalysisTransfer(path, descriptor, source, signal, capacity = {
+	nodes: JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM,
+	unknowns: JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM
+}) {
+	if (capacity !== null && [capacity.nodes, capacity.unknowns].some((value) => !Number.isSafeInteger(value) || value < 0 || value > 1e6)) throw new RangeError("JavaScript transfer requires valid retained capacities");
 	const expected = javaScriptAnalysisTransferDescriptorSchema.parse(descriptor);
 	if ((await stat(path)).size !== expected.bytes) throw new TypeError("JavaScript analysis transfer byte count does not match");
 	const scopes = [];
@@ -4329,7 +4949,7 @@ async function readJavaScriptAnalysisTransfer(path, descriptor, source, signal,
 					moduleHeader = record.value;
 				} else {
 					if (projectionHeader === undefined || moduleHeader === undefined) throw new TypeError("JavaScript transfer facts precede their headers");
-					if (!retainGraph && [
+					if (capacity === null && [
 						"evidence-context",
 						"node",
 						"relation",
@@ -4363,6 +4983,7 @@ async function readJavaScriptAnalysisTransfer(path, descriptor, source, signal,
 						case "node": {
 							retainIdentity(record.kind, record.value.node_id);
 							if (record.value.identity.artifact_sha256 !== source.sha256 || record.value.identity.module_path !== source.path) throw new TypeError("JavaScript transfer node belongs to a different artifact source");
+							if (capacity !== null && nodes.length >= capacity.nodes) throw new TypeError("JavaScript transfer nodes exceed the offered capacity");
 							nodes.push(record.value);
 							break;
 						}
@@ -4372,6 +4993,7 @@ async function readJavaScriptAnalysisTransfer(path, descriptor, source, signal,
 							break;
 						case "unknown":
 							retainIdentity(record.kind, record.value.unknown_id);
+							if (capacity !== null && unknowns.length >= capacity.unknowns) throw new TypeError("JavaScript transfer unknowns exceed the offered capacity");
 							unknowns.push(record.value);
 							break;
 						case "fingerprint":
@@ -4397,7 +5019,7 @@ async function readJavaScriptAnalysisTransfer(path, descriptor, source, signal,
 			callables,
 			moduleLinks
 		},
-		projection: retainGraph ? {
+		projection: capacity !== null ? {
 			...projectionHeader,
 			evidenceContexts,
 			nodes,
@@ -4411,6 +5033,7 @@ var JAVASCRIPT_ANALYSIS_TRANSFER_RECORD_BYTES, FRAME_BYTES, TRANSFER_BYTES, MAX_
 function init_JavaScriptAnalysisTransfer() {
 	return (init_JavaScriptAnalysisTransfer = __esmMin((() => {
 		init_analysisErrorCore();
+		init_javascriptAnalysisResourceControls();
 		init_digests();
 		init_JavaScriptAnalysisWorkerSchemas();
 		JAVASCRIPT_ANALYSIS_TRANSFER_RECORD_BYTES = 8 * 1024 * 1024;
@@ -4520,7 +5143,8 @@ function init_JavaScriptAnalysisTransfer() {
 					kind: "projection-header",
 					value: {
 						roots: projection.roots,
-						truncated: projection.truncated
+						nodesTruncated: projection.nodesTruncated,
+						...projection.omittedUnknownOccurrences === undefined ? {} : { omittedUnknownOccurrences: projection.omittedUnknownOccurrences }
 					}
 				});
 				for (const record of moduleTransferRecords(module)) await append(record);
@@ -4578,7 +5202,8 @@ function init_JavaScriptAnalysisWorkerProtocol() {
 		};
 		javaScriptWorkerRequestSchema = z.strictObject({
 			id: z.uuid(),
-			node_budget: z.number().int().min(0).max(JAVASCRIPT_SEMANTIC_NODE_MAXIMUM),
+			unknown_budget: z.number().int().min(0).max(JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM),
+			node_budget: z.number().int().min(0).max(JAVASCRIPT_SEMANTIC_ITEM_MAXIMUM),
 			text_sha256: digestSchema,
 			file: z.strictObject({
 				path: z.string(),
@@ -4714,7 +5339,7 @@ function init_JavaScriptAnalysisWorker() {
 				this.#resultBudgetBytes = Math.max(0, Math.floor((getHeapStatistics().heap_size_limit - process.memoryUsage().heapUsed - 24 * JAVASCRIPT_ANALYSIS_TRANSFER_RECORD_BYTES) / 2));
 			}
 			/** Analyze inert source; hard worker failure does not terminate this process. */
-			async analyze(file, nodeBudget, signal) {
+			async analyze(file, capacity, signal) {
 				let javascript = null;
 				let module = null;
 				let projection = null;
@@ -4746,7 +5371,8 @@ function init_JavaScriptAnalysisWorker() {
 					let offeredResultBudget = 0;
 					const request = javaScriptWorkerRequestSchema.parse({
 						id,
-						node_budget: nodeBudget,
+						node_budget: capacity.nodes,
+						unknown_budget: capacity.unknowns,
 						text_sha256: createHash("sha256").update(file.text.value).digest("hex"),
 						file: metadata
 					});
@@ -4823,7 +5449,7 @@ function init_JavaScriptAnalysisWorker() {
 						}
 						const retainGraph = moduleEstimate + graphEstimate <= remaining;
 						this.#phase = "result-admission";
-						const decoded = await readJavaScriptAnalysisTransfer(join(root.path, `${id}.records`), descriptor, file, deadline.signal, retainGraph);
+						const decoded = await readJavaScriptAnalysisTransfer(join(root.path, `${id}.records`), descriptor, file, deadline.signal, retainGraph ? capacity : null);
 						module = decoded.module;
 						projection = decoded.projection;
 						this.#estimatedRetainedBytes += moduleEstimate + (retainGraph ? graphEstimate : 0);
@@ -5285,7 +5911,10 @@ function init_JavaScriptArtifactFiles() {
 						resource
 					});
 					if (cleanup.kind === "failed") {
-						failure = { cause: ArtifactReaderFailure.withCleanup(failure === undefined ? cleanup.cause : failure.cause, ArtifactReaderFailure.cleanupObservation(cleanup.cause, resource)) };
+						failure = { cause: context.resources.cleanupFailure(failure === undefined ? { kind: "completed" } : {
+							kind: "failed",
+							cause: failure.cause
+						}, [cleanup]) };
 					}
 				}
 			}
@@ -5565,7 +6194,7 @@ function init_JavaScriptArtifactGraphAccumulator() {
 
 //#endregion
 //#region dist/application/javascript/JavaScriptArtifactGraphEvidence.js
-var EXTRACTOR, artifactObservationEvidence, astObservationEvidence, staticInferenceEvidence, unavailableAstEvidence, artifactReference;
+var EXTRACTOR, artifactObservationEvidence, astObservationEvidence, staticInferenceEvidence, unavailableStaticEvidence, artifactReference;
 function init_JavaScriptArtifactGraphEvidence() {
 	return (init_JavaScriptArtifactGraphEvidence = __esmMin((() => {
 		EXTRACTOR = {
@@ -5644,8 +6273,8 @@ function init_JavaScriptArtifactGraphEvidence() {
 			limitations: ["Static syntax does not prove that this relationship executes at runtime.", ...input.limitations ?? []],
 			evidence_ids: []
 		});
-		unavailableAstEvidence = (input) => ({
-			authority: "ast-static-analysis",
+		unavailableStaticEvidence = (input) => ({
+			authority: input.authority,
 			state: "unavailable",
 			confidence: "unknown",
 			artifact: artifactReference(input.sha256),
@@ -5733,7 +6362,7 @@ function* packageLookupDirectories(input) {
 		directory = posix.dirname(directory);
 	}
 }
-var moduleResolutionModeProperties, EXTENSIONS, PACKAGE_ARTIFACT_ROOT_URL, encodePackageMetadataUrl, packageMetadataUrl, resolveArtifactPathByContext, artifactPathResolutionProperties, conditionalResolution, resolvePath, resolveExactUrlResource, isRuntimePathDeclaration, resolveNodeRuntimeEntrypoint, resolveRuntimeEntrypoint, resolveRuntimeSourceCandidates, rejectDeclaration, declaresLiteralPercent, contextualCandidate, decodeModuleUrlPath, relativeCandidate, bareModuleCandidate, enclosingPackageMetadata, resolvePackageImportAlias, packageSelfCandidate, resolvePackageDependency, resolveLegacyEsmSubpath, resolvePackageExports, resolveExportTarget, parseBarePackageRequest, hasContainerDirectory, htmlCandidate, exactUrlPathCandidate, urlPathIsDirectory, htmlBaseDirectory, confineCandidate, readPackageMetadata, resolveCandidate, commonJsDirectoryRequest, resolveDirectory, resolveNodePackageMain, resolveFileCandidates, findFileCandidate, isRuntimeDeclarationPath, NODE_MODULE_EXTENSIONS, NODE_PACKAGE_MAIN_SUFFIXES, fileCandidates, indexCandidates, selectPackageExport, invalidExportTarget, forbiddenExportSegment, selectStringPackageTarget, selectArrayPackageTarget, selectExportTarget, packageExportConditions, notFoundCandidate, exactPackageTargetNotFound, fileUrlPath, unresolvedCandidate;
+var moduleResolutionModeProperties, EXTENSIONS, PACKAGE_ARTIFACT_ROOT_URL, encodePackageMetadataUrl, packageMetadataUrl, resolveArtifactPathByContext, artifactPathResolutionProperties, conditionalResolution, resolvePath, resolveExactUrlResource, isRuntimePathDeclaration, resolveNodeRuntimeEntrypoint, resolveRuntimeEntrypoint, resolveRuntimeSourceCandidates, rejectDeclaration, declaresLiteralPercent, contextualCandidate, decodeModuleUrlPath, relativeCandidate, urlDirectoryState, applyUrlReference, urlBaseDirectory, urlPathCandidate, urlRelativeCandidate, bareModuleCandidate, enclosingPackageMetadata, resolvePackageImportAlias, packageSelfCandidate, resolvePackageDependency, resolveLegacyEsmSubpath, resolvePackageExports, resolveExportTarget, parseBarePackageRequest, hasContainerDirectory, htmlCandidate, exactUrlPathCandidate, urlPathIsDirectory, confineCandidate, readPackageMetadata, resolveCandidate, commonJsDirectoryRequest, resolveDirectory, resolveNodePackageMain, resolveFileCandidates, findFileCandidate, isRuntimeDeclarationPath, NODE_MODULE_EXTENSIONS, NODE_PACKAGE_MAIN_SUFFIXES, fileCandidates, indexCandidates, selectPackageExport, invalidExportTarget, forbiddenExportSegment, selectStringPackageTarget, selectArrayPackageTarget, selectExportTarget, packageExportConditions, notFoundCandidate, exactPackageTargetNotFound, fileUrlPath, unresolvedCandidate;
 function init_JavaScriptArtifactPathResolution() {
 	return (init_JavaScriptArtifactPathResolution = __esmMin((() => {
 		init_artifactIdentity();
@@ -5961,11 +6590,14 @@ function init_JavaScriptArtifactPathResolution() {
 				if (/^\/[A-Za-z]:(?:\/|$)/u.test(fileReference.pathname)) return unresolvedCandidate("unavailable", ["Drive-letter URL paths cannot be mapped without the source URL scheme and filesystem root."]);
 				const decoded = percentDecodeUrlPath(declared);
 				if (decoded === null) return unresolvedCandidate("rejected", ["The URL reference path percent-decodes to NUL or to bytes that are not UTF-8."]);
-				if (decoded.includes("//")) return unresolvedCandidate("unavailable", ["Repeated URL path separators cannot be mapped to an exact canonical artifact file."]);
-				return exactUrlPathCandidate(decoded, relativeCandidate(input.sourcePath, decoded), "URL");
+				const candidate = urlRelativeCandidate(posix.dirname(input.sourcePath), decoded);
+				return typeof candidate === "string" ? exactUrlPathCandidate(decoded, candidate, "URL") : candidate;
 			}
-			const candidate = relativeCandidate(input.sourcePath, declared);
-			return context === "module-specifier" && input.moduleKind === "import" ? exactUrlPathCandidate(declared, candidate, "module URL") : candidate;
+			if (context === "module-specifier" && input.moduleKind === "import") {
+				const candidate = urlRelativeCandidate(posix.dirname(input.sourcePath), declared);
+				return typeof candidate === "string" ? exactUrlPathCandidate(declared, candidate, "module URL") : candidate;
+			}
+			return relativeCandidate(input.sourcePath, declared);
 		};
 		decodeModuleUrlPath = (declared) => {
 			let decoded;
@@ -5978,6 +6610,39 @@ function init_JavaScriptArtifactPathResolution() {
 			return decoded.includes("\0") ? unresolvedCandidate("rejected", ["The decoded module URL path contains NUL."]) : decoded;
 		};
 		relativeCandidate = (sourcePath, declared) => declared.startsWith("/") ? declared.slice(1) : posix.join(posix.dirname(sourcePath), declared);
+		urlDirectoryState = (directory) => ({
+			escapes: 0,
+			segments: directory === "" || directory === "." ? [] : directory.split("/")
+		});
+		applyUrlReference = (base, reference) => {
+			const absolute = reference.startsWith("/");
+			const segments = absolute ? [] : [...base.segments];
+			let escapes = absolute ? 0 : base.escapes;
+			const parts = (absolute ? reference.slice(1) : reference).split("/");
+			for (const [index, part] of parts.entries()) {
+				if (part !== "." && part !== "..") {
+					segments.push(part);
+					continue;
+				}
+				if (part === "..") if (segments.length > 0) segments.pop();
+				else escapes += 1;
+				if (index === parts.length - 1) segments.push("");
+			}
+			return {
+				escapes,
+				segments
+			};
+		};
+		urlBaseDirectory = (base) => ({
+			escapes: base.escapes,
+			segments: base.segments.slice(0, -1)
+		});
+		urlPathCandidate = (path) => {
+			const segments = path.segments.at(-1) === "" ? path.segments.slice(0, -1) : path.segments;
+			if (segments.includes("")) return unresolvedCandidate("unavailable", ["Repeated URL path separators cannot be mapped to an exact canonical artifact file."]);
+			return [...Array.from({ length: path.escapes }, () => ".."), ...segments].join("/");
+		};
+		urlRelativeCandidate = (directory, reference) => urlPathCandidate(applyUrlReference(urlDirectoryState(directory), reference));
 		bareModuleCandidate = (input) => {
 			const request = parseBarePackageRequest(input.declaredPath, input.moduleKind);
 			if (request === null || isBuiltin(input.declaredPath)) return unresolvedCandidate("external", ["The bare specifier is a Node builtin or invalid package name."]);
@@ -6118,11 +6783,15 @@ function init_JavaScriptArtifactPathResolution() {
 		parseBarePackageRequest = (specifier, moduleKind) => {
 			const segments = specifier.split("/");
 			let packageName = segments[0] ?? "";
-			if (packageName === "") return null;
+			if (packageName === "" || packageName === "@") return null;
 			if (specifier.startsWith("@")) {
 				const packageSegment = segments[1];
-				if (packageSegment === undefined || packageSegment === "") return null;
-				packageName = `${packageName}/${packageSegment}`;
+				if (packageSegment !== undefined && packageSegment !== "") {
+					packageName = `${packageName}/${packageSegment}`;
+				} else if (moduleKind !== "require") {
+					if (packageSegment === undefined) return null;
+					packageName = `${packageName}/`;
+				}
 			}
 			const dependencyExportsEligible = moduleKind !== "require" || /^((?:@[^/\\%]+\/)?[^./\\%][^/\\%]*)(\/.*)?$/.exec(specifier)?.[1] === packageName;
 			return {
@@ -6151,14 +6820,17 @@ function init_JavaScriptArtifactPathResolution() {
 			if (base !== undefined && base !== null && looksExternal(base)) return unresolvedCandidate("external", ["The document base href is external, so its script reference is not a local artifact path."]);
 			const declaredPath = percentDecodeUrlPath(declared);
 			if (declaredPath === null) return unresolvedCandidate("rejected", ["The HTML reference path percent-decodes to NUL or to bytes that are not UTF-8."]);
-			if (declaredPath.startsWith("/")) return declaredPath.slice(1);
-			if (base === undefined || base === null || base === "") return declaredPath === "" ? input.sourcePath : posix.join(posix.dirname(input.sourcePath), declaredPath);
+			if (declaredPath.startsWith("/")) return urlRelativeCandidate("", declaredPath);
+			if (base === undefined || base === null || base === "") return declaredPath === "" ? input.sourcePath : urlRelativeCandidate(posix.dirname(input.sourcePath), declaredPath);
 			if (!admitsCanonicalPathSyntax(base)) return unresolvedCandidate("rejected", ["The document base href uses NUL, backslash, or encoded dot and separator bytes that are not admitted for canonical artifact paths."]);
 			const decodedBase = percentDecodeUrlPath(base);
 			if (decodedBase === null) return unresolvedCandidate("rejected", ["The document base href path percent-decodes to NUL or to bytes that are not UTF-8."]);
-			const basePath = decodedBase.startsWith("/") ? decodedBase.slice(1) : posix.join(posix.dirname(input.sourcePath), decodedBase);
-			if (declaredPath === "") return exactUrlPathCandidate(decodedBase, basePath, "HTML");
-			return posix.join(htmlBaseDirectory(decodedBase, basePath), declaredPath);
+			const baseState = applyUrlReference(urlDirectoryState(posix.dirname(input.sourcePath)), decodedBase);
+			if (declaredPath === "") {
+				const basePath = urlPathCandidate(baseState);
+				return typeof basePath === "string" ? exactUrlPathCandidate(decodedBase, basePath, "HTML") : basePath;
+			}
+			return urlPathCandidate(applyUrlReference(urlBaseDirectory(baseState), declaredPath));
 		};
 		exactUrlPathCandidate = (declared, candidate, kind) => {
 			if (!urlPathIsDirectory(declared)) return candidate;
@@ -6167,7 +6839,6 @@ function init_JavaScriptArtifactPathResolution() {
 			return unresolvedCandidate("not-found", [`The ${kind} reference resolves to directory ${confined || "."}, not an exact selected application file.`]);
 		};
 		urlPathIsDirectory = (path) => path.endsWith("/") || path.endsWith("/.") || path.endsWith("/..") || path === "." || path === "..";
-		htmlBaseDirectory = (base, basePath) => urlPathIsDirectory(base) ? basePath : posix.dirname(basePath);
 		confineCandidate = (candidate) => {
 			const normalized = normalizeJoinedLogicalPath(candidate);
 			if (logicalPathEscapesRoot(normalized)) return unresolvedCandidate("rejected", ["The resolved candidate escapes the canonical artifact root."]);
@@ -6569,7 +7240,8 @@ function init_JavaScriptArtifactGraphContext() {
 						limitation: input.limitation,
 						...input.failure === undefined ? {} : { analysis_failure: input.failure }
 					},
-					evidence: unavailableAstEvidence({
+					evidence: unavailableStaticEvidence({
+						authority: input.authority,
 						sha256: input.file.sha256,
 						path: input.file.path,
 						operation: input.operation,
@@ -6977,18 +7649,25 @@ function init_JavaScriptArtifactGraphFindings() {
 			const source = sourceNodeFor(context, input.file.path, input.value.module_key, input.value.module_runtime) ?? input.asset;
 			const key = compactStringIdentityKey(input.value.value);
 			const candidate = input.value.interpretation === "candidate";
+			const partial = input.value.resolution === "partial";
 			const candidateLimitation = "The unbound method-like argument is only a candidate; its receiver does not establish a network call.";
+			const partialLimitation = "The request target is not an exact literal; the endpoint value retains the unresolved source expression.";
 			const label = `${input.value.kind} ${candidate ? "endpoint candidate" : "endpoint"}`;
 			const node = context.accumulator.addNode({
 				kind: "endpoint",
-				identity: artifactLocalIdentity(input.file.sha256, input.value.kind, JSON.stringify([input.value.interpretation ?? "literal", key])),
+				identity: artifactLocalIdentity(input.file.sha256, input.value.kind, JSON.stringify([
+					input.value.interpretation ?? "literal",
+					...partial ? ["partial", input.value.location] : [],
+					key
+				])),
 				observations: [{
 					label: input.value.value.length <= label.length ? input.value.value : label,
 					properties: {
 						endpoint_kind: input.value.kind,
 						value: input.value.value,
 						mechanism: input.value.mechanism,
-						...candidate ? { interpretation: input.value.interpretation } : {}
+						...candidate ? { interpretation: input.value.interpretation } : {},
+						...partial ? { resolution: input.value.resolution } : {}
 					},
 					evidence: candidate ? staticInferenceEvidence({
 						sha256: input.file.sha256,
@@ -7003,7 +7682,8 @@ function init_JavaScriptArtifactGraphFindings() {
 						path: input.file.path,
 						range: input.value.location,
 						operation: "discover-static-endpoint",
-						coverage: input.coverage
+						coverage: input.coverage,
+						...partial ? { limitations: [partialLimitation] } : {}
 					})
 				}]
 			});
@@ -7016,27 +7696,39 @@ function init_JavaScriptArtifactGraphFindings() {
 				relation: input.value.kind === "route" ? "exposes" : "calls",
 				properties: {
 					mechanism: input.value.mechanism,
-					...candidate ? { interpretation: input.value.interpretation } : {}
+					...candidate ? { interpretation: input.value.interpretation } : {},
+					...partial ? { resolution: input.value.resolution } : {}
 				},
 				...candidate ? {
 					confidence: "low",
 					limitations: [candidateLimitation]
-				} : {}
+				} : partial ? { limitations: [partialLimitation] } : {}
 			});
 		};
 		addStorage = (context, input) => {
+			const candidate = input.value.interpretation === "candidate";
+			const limitation = "The constructor name is only a candidate; an unchanged SQLite module API origin is unproven.";
 			const source = sourceNodeFor(context, input.file.path, input.value.module_key, input.value.module_runtime) ?? input.asset;
 			const node = context.accumulator.addNode({
 				kind: "storage",
-				identity: artifactLocalIdentity(input.file.sha256, input.value.kind, input.value.name ?? input.value.mechanism),
+				identity: artifactLocalIdentity(input.file.sha256, candidate ? `${input.value.kind}:candidate` : input.value.kind, input.value.name ?? input.value.mechanism),
 				observations: [{
 					label: input.value.name ?? input.value.kind,
 					properties: {
 						storage_kind: input.value.kind,
 						name: input.value.name,
-						mechanism: input.value.mechanism
+						mechanism: input.value.mechanism,
+						...candidate ? { interpretation: "candidate" } : {}
 					},
-					evidence: astObservationEvidence({
+					evidence: candidate ? staticInferenceEvidence({
+						sha256: input.file.sha256,
+						path: input.file.path,
+						range: input.value.location,
+						operation: "classify-static-storage-candidate",
+						coverage: input.coverage,
+						confidence: "low",
+						limitations: [limitation]
+					}) : astObservationEvidence({
 						sha256: input.file.sha256,
 						path: input.file.path,
 						range: input.value.location,
@@ -7052,7 +7744,14 @@ function init_JavaScriptArtifactGraphFindings() {
 				range: input.value.location,
 				coverage: input.coverage,
 				relation: "persists_to",
-				properties: { mechanism: input.value.mechanism }
+				properties: {
+					mechanism: input.value.mechanism,
+					...candidate ? { interpretation: "candidate" } : {}
+				},
+				...candidate ? {
+					confidence: "low",
+					limitations: [limitation]
+				} : {}
 			});
 		};
 		addDiscoveredRole = (context, input) => {
@@ -7305,8 +8004,8 @@ function init_JavaScriptModuleRelationships() {
 						label: file.path,
 						properties: {
 							semantic_role: "source-module",
+							source_sha256: file.sha256,
 							path: file.path,
-							container_sha256: file.container_sha256,
 							logical_module_key: file.path,
 							module_format: moduleFormat(file.path, semantic.ir),
 							import_relationships: semantic.ir.moduleLinks.filter(({ kind }) => kind === "import" || kind === "require").length,
@@ -7540,6 +8239,7 @@ function init_JavaScriptArtifactGraphStructure() {
 	return (init_JavaScriptArtifactGraphStructure = __esmMin((() => {
 		init_JavaScriptArtifactAnalysis();
 		init_javascriptApplicationEvidenceSchemas();
+		init_JavaScriptArtifactAnalysisTypes();
 		init_jsonValue();
 		init_immutableJson();
 		init_JavaScriptArtifactGraphContext();
@@ -7622,7 +8322,7 @@ function init_JavaScriptArtifactGraphStructure() {
 			for (const analyzed of context.analysis.files) {
 				const { file } = analyzed;
 				const jsonValue = jsonModulesByPath.get(file.path);
-				const target = createFileTarget(context, file, analyzed.javascript, jsonValue);
+				const target = createFileTarget(context, file, analyzed.javascript, jsonValue, isSkippedJavaScriptAnalysis(analyzed));
 				if (analyzed.application_projection_failure !== undefined && analyzed.javascript !== null) context.accumulator.addNode({
 					kind: target.kind,
 					identity: target.identity,
@@ -7673,30 +8373,35 @@ function init_JavaScriptArtifactGraphStructure() {
 						})
 					});
 				}
-				if (!file.text.included && file.text.reason === "outside-analysis-scope") addUnavailableStaticParseScope(context, {
+				const analysisScope = javascriptArtifactAnalysisScopes[file.kind];
+				if (!file.text.included && file.text.reason === "outside-analysis-scope" && analysisScope !== null) addUnavailableStaticParseScope(context, {
 					file,
 					asset: target,
 					operation: "select-javascript-sources",
+					authority: analysisScope.authority,
 					limitation: "Source is outside the caller-selected source_paths; it was inventoried but not analyzed."
 				});
 				else if (analyzed.analysis_failure !== undefined) addUnavailableStaticParseScope(context, {
 					file,
 					asset: target,
-					operation: "analyze-javascript-source",
+					...analyzed.analysis_failure.scope,
 					limitation: analyzed.analysis_failure.reason,
 					failure: analyzed.analysis_failure.error,
-					limits: javaScriptAnalysisCoverageLimits(analyzed.analysis_failure.limits)
+					limits: javaScriptAnalysisCoverageLimits(analyzed.analysis_failure.limits),
+					details: { analysis_status: analyzed.analysis_failure.status }
 				});
 				else if (file.kind === "javascript" && (analyzed.javascript === null || analyzed.javascript.parse_status === "failed")) addUnavailableStaticParseScope(context, {
 					file,
 					asset: target,
 					operation: "parse-javascript",
+					authority: javascriptArtifactAnalysisScopes.javascript.authority,
 					limitation: file.text.included ? "JavaScript syntax could not be parsed." : `JavaScript text was unavailable: ${file.text.reason}.`
 				});
 				if (analyzed.application_projection_failure !== undefined) addUnavailableStaticParseScope(context, {
 					file,
 					asset: target,
 					operation: "project-javascript-application",
+					authority: javascriptArtifactAnalysisScopes.javascript.authority,
 					limitation: analyzed.application_projection_failure.reason,
 					failure: analyzed.application_projection_failure.error,
 					limits: javaScriptAnalysisCoverageLimits(analyzed.application_projection_failure.limits)
@@ -7705,20 +8410,20 @@ function init_JavaScriptArtifactGraphStructure() {
 				if (packageValue !== undefined && packageValue.status !== "included") addUnavailableStaticParseScope(context, {
 					file,
 					asset: target,
-					operation: "parse-package-json",
+					...javascriptArtifactAnalysisScopes["package-json"],
 					limitation: packageValue.limitation
 				});
 				if (jsonValue !== undefined && jsonValue.status !== "included") addUnavailableStaticParseScope(context, {
 					file,
 					asset: target,
-					operation: "parse-json-module",
+					...javascriptArtifactAnalysisScopes.json,
 					limitation: jsonValue.limitation
 				});
 				const sourceMap = sourceMapsByPath.get(file.path);
 				if (sourceMap !== undefined && sourceMap.status === "invalid") addUnavailableStaticParseScope(context, {
 					file,
 					asset: target,
-					operation: "parse-local-source-map",
+					...javascriptArtifactAnalysisScopes["source-map"],
 					limitation: sourceMap.limitation
 				});
 				const inlineScripts = inlineScriptsByPath.get(file.path);
@@ -7726,6 +8431,7 @@ function init_JavaScriptArtifactGraphStructure() {
 					file,
 					asset: target,
 					operation: "parse-html-inline-scripts",
+					authority: javascriptArtifactAnalysisScopes.javascript.authority,
 					limitation: htmlInlineScriptLimitation(inlineScripts),
 					limits: inlineScripts.script_count > inlineScripts.scripts.length ? [HTML_INLINE_SCRIPT_LOCATION_COVERAGE_LIMIT] : [],
 					omittedCount: omittedHtmlInlineScriptLocations([inlineScripts]),
@@ -7927,7 +8633,7 @@ function init_JavaScriptArtifactGraphStructure() {
 		};
 		applicationManifestPath = (context) => context.analysis.packages.map(({ path }) => path).filter((path) => context.filesByPath.has(path) && !dependencyManifest(path)).sort((left, right) => left.split("/").length - right.split("/").length || compareUnicodeCodePoints(left, right))[0];
 		dependencyManifest = (path) => path.split("/").slice(0, -1).includes("node_modules");
-		createFileTarget = (context, file, javascript, json) => {
+		createFileTarget = (context, file, javascript, json, skipped) => {
 			const kind = artifactFileNodeKind(file.kind);
 			return context.accumulator.addNode({
 				kind,
@@ -7945,7 +8651,7 @@ function init_JavaScriptArtifactGraphStructure() {
 						unpacked: file.unpacked,
 						file_kind: file.kind,
 						text_status: file.text.included ? "included" : file.text.reason,
-						parse_status: javascript?.parse_status ?? null,
+						parse_status: javascript?.parse_status ?? (skipped ? "skipped" : null),
 						json_parse_status: json?.status ?? null,
 						json_top_level_keys: json?.top_level_keys ?? [],
 						omitted_json_top_level_keys: json?.omitted_top_level_keys ?? 0,
@@ -8822,13 +9528,17 @@ function init_ElectronBoundaryGraphWindows() {
 						web_preferences: value.web_preferences,
 						preload_path: value.preload_path,
 						preload_resolution_context: value.preload_resolution_context,
+						...value.resolution_sources === undefined ? {} : { resolution_sources: value.resolution_sources.map((location) => ({
+							source: file.path,
+							...location
+						})) },
 						absence_means_default: false
 					},
-					evidence: astObservationEvidence({
+					evidence: (value.resolution_sources === undefined ? astObservationEvidence : staticInferenceEvidence)({
 						sha256: file.sha256,
 						path: file.path,
 						range: value.location,
-						operation: "observe-browser-window-construction",
+						operation: value.resolution_sources === undefined ? "observe-browser-window-construction" : "resolve-browser-window-constant-options",
 						coverage,
 						limitations: ["Only explicitly present webPreferences are reported; omitted properties are not interpreted as Electron defaults."]
 					})
@@ -9437,7 +10147,7 @@ function init_JavaScriptSemanticGraphEvidence() {
 
 //#endregion
 //#region dist/application/javascript/JavaScriptSemanticGraphConstruction.js
-var createSemanticGraphProjectionState, bindSemanticGraphApplicationNodes, constructSemanticGraphNode, retainSemanticGraphNode, addSemanticGraphNode, addSemanticGraphRelation, addSemanticGraphUnknown, addSemanticFallbackRoot, indexApplicationNodes, addApplicationNodeIdentifier, applicationLocationKey;
+var createSemanticGraphProjectionState, bindSemanticGraphApplicationNodes, constructSemanticGraphNode, retainSemanticGraphNode, addSemanticGraphNode, addSemanticGraphRelation, recordSemanticUnknownOmission, addSemanticGraphUnknown, addSemanticFallbackRoot, indexApplicationNodes, addApplicationNodeIdentifier, applicationLocationKey;
 function init_JavaScriptSemanticGraphConstruction() {
 	return (init_JavaScriptSemanticGraphConstruction = __esmMin((() => {
 		init_javascriptAstValues();
@@ -9447,6 +10157,8 @@ function init_JavaScriptSemanticGraphConstruction() {
 			nodes: new Map(),
 			relations: new Map(),
 			unknowns: new Map(),
+			unknownCapacity: null,
+			unknownOmissions: new Map(),
 			evidenceContexts: new JavaScriptSemanticEvidenceContextRegistry(),
 			roots: new Set()
 		});
@@ -9518,7 +10230,25 @@ function init_JavaScriptSemanticGraphConstruction() {
 			if (state.relations.has(value.relation_id)) return;
 			state.relations.set(value.relation_id, value);
 		};
-		addSemanticGraphUnknown = (state, unknown) => {
+		recordSemanticUnknownOmission = (state, omission) => {
+			const key = `${omission.family}:${omission.reason}`;
+			const occurrences = (state.unknownOmissions.get(key)?.occurrences ?? 0) + omission.occurrences;
+			if (!Number.isSafeInteger(occurrences)) throw new RangeError("Semantic unknown omission count overflow");
+			state.unknownOmissions.set(key, {
+				...omission,
+				occurrences
+			});
+		};
+		addSemanticGraphUnknown = (state, input) => {
+			if (state.unknownCapacity !== null && state.unknowns.size >= state.unknownCapacity) {
+				recordSemanticUnknownOmission(state, {
+					family: input.family,
+					reason: input.reason,
+					occurrences: 1
+				});
+				return;
+			}
+			const unknown = createJavaScriptSemanticGraphUnknown(input, state.evidenceContexts);
 			if (state.unknowns.has(unknown.unknown_id)) return;
 			state.unknowns.set(unknown.unknown_id, unknown);
 		};
@@ -9581,7 +10311,6 @@ var projectSemanticEvents, addEventNode, addListenerNode, eventEmitterNode, even
 function init_JavaScriptSemanticGraphAsyncProjection() {
 	return (init_JavaScriptSemanticGraphAsyncProjection = __esmMin((() => {
 		init_compactStringIdentity();
-		init_javascriptSemanticGraph();
 		init_JavaScriptSemanticGraphConstruction();
 		init_JavaScriptSemanticGraphEvidence();
 		projectSemanticEvents = (context) => {
@@ -9636,7 +10365,7 @@ function init_JavaScriptSemanticGraphAsyncProjection() {
 		eventEmitterNode = (context, operation) => (operation.emitterBindingId === null ? undefined : context.bindingNodes.get(operation.emitterBindingId)) ?? (operation.ownerCallableId === null ? context.moduleNode : context.callableNodes.get(operation.ownerCallableId) ?? context.moduleNode);
 		eventRelation = (operation) => operation.kind === "register" ? "registers-listener" : operation.kind === "remove" ? "removes-listener" : "dispatches-candidate";
 		addEventUnknown = (context, operation, event, relation) => {
-			addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+			addSemanticGraphUnknown(context.state, {
 				node_id: event.node_id,
 				family: "event",
 				relation_kinds: [relation],
@@ -9644,7 +10373,7 @@ function init_JavaScriptSemanticGraphAsyncProjection() {
 				detail: operation.eventName === null ? `Dynamic ${operation.method} event name remains unresolved.` : `Static ${operation.method} emitter identity is partial.`,
 				candidate_node_ids: [],
 				evidence: unknownSemanticEvidence(context.file, operation.location)
-			}, context.state.evidenceContexts));
+			});
 		};
 		projectSemanticTimers = (context) => {
 			const timerNodes = new Map(context.ir.timerOperations.flatMap((operation) => {
@@ -9694,7 +10423,7 @@ function init_JavaScriptSemanticGraphAsyncProjection() {
 				resolution: operation.resolution === "complete" ? "resolved" : "candidate"
 			});
 			if (operation.resolution === "complete") return;
-			addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+			addSemanticGraphUnknown(context.state, {
 				node_id: callSite?.node_id ?? null,
 				family: "timer",
 				relation_kinds: ["cancels-timer"],
@@ -9702,7 +10431,7 @@ function init_JavaScriptSemanticGraphAsyncProjection() {
 				detail: `Static ${operation.method} handle resolution was ${operation.resolution}.`,
 				candidate_node_ids: [],
 				evidence: unknownSemanticEvidence(context.file, operation.location)
-			}, context.state.evidenceContexts));
+			});
 		};
 	})))();
 }
@@ -9712,7 +10441,6 @@ function init_JavaScriptSemanticGraphAsyncProjection() {
 var projectSemanticChildProcesses, addChildProcessNode, projectSpawn, addStdioNode, projectInteraction, addChildListenerNode, addSignalNode, addChildUnknown;
 function init_JavaScriptSemanticGraphChildProcessProjection() {
 	return (init_JavaScriptSemanticGraphChildProcessProjection = __esmMin((() => {
-		init_javascriptSemanticGraph();
 		init_JavaScriptSemanticGraphConstruction();
 		init_JavaScriptSemanticGraphEvidence();
 		projectSemanticChildProcesses = (context) => {
@@ -9779,6 +10507,15 @@ function init_JavaScriptSemanticGraphChildProcessProjection() {
 				relation: "connects-stdio",
 				resolution: spawn.stdioMode === "dynamic" ? "candidate" : "resolved"
 			});
+			if (spawn.stdioMode === "dynamic") addChildUnknown({
+				context,
+				node: child,
+				location: spawn.location,
+				relationKinds: ["connects-stdio"],
+				reason: "unknown-value",
+				detail: `Static ${spawn.method} stdio options remain unresolved.`,
+				candidateNodeIds: []
+			});
 			if (spawn.resolution !== "complete") addChildUnknown({
 				context,
 				node: child,
@@ -9838,15 +10575,15 @@ function init_JavaScriptSemanticGraphChildProcessProjection() {
 		});
 		addChildUnknown = (input) => {
 			const { context, node, location, relationKinds, detail, candidateNodeIds } = input;
-			addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+			addSemanticGraphUnknown(context.state, {
 				node_id: node?.node_id ?? null,
 				family: "child-process",
 				relation_kinds: relationKinds,
-				reason: "ambiguous-target",
+				reason: input.reason ?? "ambiguous-target",
 				detail,
 				candidate_node_ids: candidateNodeIds,
 				evidence: unknownSemanticEvidence(context.file, location)
-			}, context.state.evidenceContexts));
+			});
 		};
 	})))();
 }
@@ -9856,9 +10593,9 @@ function init_JavaScriptSemanticGraphChildProcessProjection() {
 var projectSemanticConfiguration, addConfigurationNode, configurationRelation, projectSemanticRequests, addRequestNode, projectRequestConstruction, projectResponseConsumer, projectSemanticBoundaries, addBoundaryNode, bindingOrOwner, addDataUnknown;
 function init_JavaScriptSemanticGraphDataProjection() {
 	return (init_JavaScriptSemanticGraphDataProjection = __esmMin((() => {
-		init_javascriptSemanticGraph();
 		init_JavaScriptSemanticGraphConstruction();
 		init_JavaScriptSemanticGraphEvidence();
+		init_javascriptSemanticResourceLimits();
 		projectSemanticConfiguration = (context) => {
 			const configNodes = new Map(context.ir.configurationOperations.flatMap((operation) => {
 				const node = addConfigurationNode(context, operation);
@@ -9886,7 +10623,10 @@ function init_JavaScriptSemanticGraphDataProjection() {
 					family: "configuration",
 					relationKinds: [configurationRelation(operation), ...operation.kind === "default" ? ["overrides"] : []],
 					location: operation.location,
-					detail: `Static ${operation.kind} configuration identity is partial.`,
+					...operation.valueResourceLimit === undefined ? { detail: operation.kind === "default" ? "Static default configuration value is partial." : `Static ${operation.kind} configuration identity is partial.` } : {
+						reason: "resource-limit",
+						detail: semanticResourceLimitReason(operation.valueResourceLimit)
+					},
 					candidateNodeIds: []
 				});
 			}
@@ -9900,7 +10640,8 @@ function init_JavaScriptSemanticGraphDataProjection() {
 			properties: {
 				key: operation.key,
 				source_kind: operation.kind,
-				value: operation.value
+				value: operation.value,
+				...operation.valueResourceLimit === undefined ? {} : { value_resource_limit: operation.valueResourceLimit }
 			}
 		});
 		configurationRelation = (operation) => operation.kind === "environment" ? "reads-environment" : operation.kind === "argv" ? "reads-argv" : operation.kind === "file" ? "reads-config" : "defaults";
@@ -10004,21 +10745,22 @@ function init_JavaScriptSemanticGraphDataProjection() {
 			functionNodeId: operation.ownerCallableId === null ? null : context.callableNodes.get(operation.ownerCallableId)?.node_id ?? null,
 			properties: {
 				boundary_kind: operation.kind,
+				field: operation.method,
 				method: operation.method
 			}
 		});
 		bindingOrOwner = (context, bindingId, callableId) => (bindingId === null ? undefined : context.bindingNodes.get(bindingId)) ?? (callableId === null ? context.moduleNode : context.callableNodes.get(callableId) ?? context.moduleNode);
 		addDataUnknown = (input) => {
 			const { context, node, family, relationKinds, location, detail, candidateNodeIds } = input;
-			addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+			addSemanticGraphUnknown(context.state, {
 				node_id: node.node_id,
 				family,
 				relation_kinds: relationKinds,
-				reason: "ambiguous-target",
+				reason: input.reason ?? "ambiguous-target",
 				detail,
 				candidate_node_ids: candidateNodeIds,
 				evidence: unknownSemanticEvidence(context.file, location)
-			}, context.state.evidenceContexts));
+			});
 		};
 	})))();
 }
@@ -10028,7 +10770,6 @@ function init_JavaScriptSemanticGraphDataProjection() {
 var projectSemanticResources, addResourceNode, projectRelease;
 function init_JavaScriptSemanticGraphResourceProjection() {
 	return (init_JavaScriptSemanticGraphResourceProjection = __esmMin((() => {
-		init_javascriptSemanticGraph();
 		init_JavaScriptSemanticGraphConstruction();
 		init_JavaScriptSemanticGraphEvidence();
 		projectSemanticResources = (context) => {
@@ -10066,7 +10807,7 @@ function init_JavaScriptSemanticGraphResourceProjection() {
 				resolution: operation.resolution === "complete" ? "resolved" : "candidate"
 			});
 			if (operation.resolution === "complete") return;
-			addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+			addSemanticGraphUnknown(context.state, {
 				node_id: callSite?.node_id ?? null,
 				family: "resource-lifecycle",
 				relation_kinds: ["releases"],
@@ -10074,7 +10815,7 @@ function init_JavaScriptSemanticGraphResourceProjection() {
 				detail: `Static ${operation.method} resource ownership is ambiguous.`,
 				candidate_node_ids: resources.map(({ node_id: identifier }) => identifier),
 				evidence: unknownSemanticEvidence(context.file, operation.location)
-			}, context.state.evidenceContexts));
+			});
 		};
 	})))();
 }
@@ -10086,7 +10827,6 @@ function init_JavaScriptSemanticGraphValueProjection() {
 	return (init_JavaScriptSemanticGraphValueProjection = __esmMin((() => {
 		init_javascriptSemanticSlots();
 		init_canonicalDigest();
-		init_javascriptSemanticGraph();
 		init_JavaScriptSemanticGraphConstruction();
 		init_JavaScriptSemanticGraphEvidence();
 		projectSemanticValues = (context) => {
@@ -10143,7 +10883,7 @@ function init_JavaScriptSemanticGraphValueProjection() {
 						path: propertyPath
 					});
 				}
-				if (container.coverage.status === "partial") addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+				if (container.coverage.status === "partial") addSemanticGraphUnknown(context.state, {
 					node_id: target.node_id,
 					family: "object-flow",
 					relation_kinds: ["writes-property"],
@@ -10151,11 +10891,11 @@ function init_JavaScriptSemanticGraphValueProjection() {
 					detail: `Initializer container has unknown ${value.status === "object" ? "properties" : "items"}${container.coverage.omitted === null ? " with an unknown omitted count" : `; ${container.coverage.omitted} omitted`}.`,
 					candidate_node_ids: [target.node_id],
 					evidence: unknownSemanticEvidence(context.file, binding.definitions[0]?.location ?? null)
-				}, context.state.evidenceContexts));
+				});
 			} else if (value.status === "unknown" || value.status === "ambiguous" || value.status === "cycle") {
 				const location = binding.definitions[0]?.location ?? null;
 				const evidence = observedSemanticEvidence(context.file, location);
-				addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+				addSemanticGraphUnknown(context.state, {
 					node_id: target.node_id,
 					family: "data-flow",
 					relation_kinds: ["defines"],
@@ -10169,7 +10909,7 @@ function init_JavaScriptSemanticGraphValueProjection() {
 						confidence: "unknown",
 						limitations: [value.reason]
 					}
-				}, context.state.evidenceContexts));
+				});
 			}
 		};
 		addLiteralNode = (context, binding, value, role) => {
@@ -10228,7 +10968,6 @@ var OBJECT_RELATIONS, objectTarget, objectRelationEnds, addObjectOccurrence, add
 function init_JavaScriptSemanticGraphObjectProjection() {
 	return (init_JavaScriptSemanticGraphObjectProjection = __esmMin((() => {
 		init_javascriptSemanticSlots();
-		init_javascriptSemanticGraph();
 		init_JavaScriptSemanticGraphConstruction();
 		init_JavaScriptSemanticGraphEvidence();
 		init_JavaScriptSemanticGraphValueProjection();
@@ -10296,7 +11035,7 @@ function init_JavaScriptSemanticGraphObjectProjection() {
 		});
 		addObjectUnknown = (context, operation, node, target) => {
 			const relation = OBJECT_RELATIONS[operation.kind];
-			addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+			addSemanticGraphUnknown(context.state, {
 				node_id: node?.node_id ?? null,
 				family: "object-flow",
 				relation_kinds: [relation],
@@ -10304,7 +11043,7 @@ function init_JavaScriptSemanticGraphObjectProjection() {
 				detail: `Static ${operation.kind} property ${operation.propertyPath === null ? "path is unresolved" : semanticPropertyPointer(operation.propertyPath)} has ${target.presence} presence; its receiver is ${target.receiverResolved ? "a retained container" : "unresolved or not a retained container"}; object identity is ${operation.resolution}.`,
 				candidate_node_ids: [],
 				evidence: unknownSemanticEvidence(context.file, operation.location)
-			}, context.state.evidenceContexts));
+			});
 		};
 	})))();
 }
@@ -10346,7 +11085,7 @@ function* projectSemanticFrontiers(context) {
 		if (index % 64 === 0) yield;
 		const family = frontier.kind === "dynamic-call" ? "call-flow" : frontier.kind === "dynamic-scope" ? "data-flow" : "object-flow";
 		const relationKinds = frontier.kind === "dynamic-call" ? ["calls"] : frontier.kind === "dynamic-scope" ? ["reads", "writes"] : ["reads-property", "writes-property"];
-		const unknown = createJavaScriptSemanticGraphUnknown({
+		addSemanticGraphUnknown(context.state, {
 			node_id: frontier.callableId === null ? context.moduleNode.node_id : context.callableNodes.get(frontier.callableId)?.node_id ?? context.moduleNode.node_id,
 			family,
 			relation_kinds: [...relationKinds],
@@ -10354,14 +11093,12 @@ function* projectSemanticFrontiers(context) {
 			detail: frontier.reason,
 			candidate_node_ids: [],
 			evidence: unknownSemanticEvidence(context.file, frontier.location)
-		}, context.state.evidenceContexts);
-		addSemanticGraphUnknown(context.state, unknown);
+		});
 	}
 }
 var projectSemanticPromises, promiseLabel, projectPromiseCreation, projectPromiseSources, projectPromiseOwnership, addPromiseUnknown, projectSemanticReturnValues, projectSemanticClosureCaptures;
 function init_JavaScriptSemanticGraphFlowProjection() {
 	return (init_JavaScriptSemanticGraphFlowProjection = __esmMin((() => {
-		init_javascriptSemanticGraph();
 		init_javascriptStaticAnalysisHelpers();
 		init_JavaScriptSemanticGraphConstruction();
 		init_JavaScriptSemanticGraphEvidence();
@@ -10452,7 +11189,7 @@ function init_JavaScriptSemanticGraphFlowProjection() {
 		};
 		addPromiseUnknown = (context, operation, promise, promiseNodes) => {
 			const relation = operation.kind === "aggregate" ? "aggregates" : "chains";
-			addSemanticGraphUnknown(context.state, createJavaScriptSemanticGraphUnknown({
+			addSemanticGraphUnknown(context.state, {
 				node_id: promise.node_id,
 				family: "promise-ownership",
 				relation_kinds: [relation],
@@ -10463,7 +11200,7 @@ function init_JavaScriptSemanticGraphFlowProjection() {
 					return candidate === undefined ? [] : [candidate.node_id];
 				}),
 				evidence: unknownSemanticEvidence(context.file, operation.location)
-			}, context.state.evidenceContexts));
+			});
 		};
 		projectSemanticReturnValues = (context) => {
 			for (const callable of context.ir.callables) for (const site of callable.returnSites) {
@@ -10672,11 +11409,12 @@ function init_JavaScriptSemanticGraphElectronProjection() {
 
 //#endregion
 //#region dist/application/javascript/JavaScriptSemanticGraphBuilder.js
-/** Project one source with the parent's remaining node capacity, retaining no full IR. */
-function* projectJavaScriptSemanticFileSteps(file, ir, nodeBudget, paths = []) {
-	if (!Number.isSafeInteger(nodeBudget) || nodeBudget < 0 || nodeBudget > 1e6) throw new RangeError("File semantic projection requires a valid offered node capacity");
+/** Project one source with the parent's remaining retained capacities, retaining no full IR. */
+function* projectJavaScriptSemanticFileSteps(file, ir, capacity, paths = []) {
+	if ([capacity.nodes, capacity.unknowns].some((value) => !Number.isSafeInteger(value) || value < 0 || value > 1e6)) throw new RangeError("File semantic projection requires valid offered retained capacities");
 	const state = createSemanticGraphProjectionState();
-	state.fileNodeBudget = nodeBudget;
+	state.fileNodeBudget = capacity.nodes;
+	state.unknownCapacity = capacity.unknowns;
 	state.fileNodesDropped = false;
 	const fingerprints = yield* projectFileSteps(file, ir, state, paths);
 	return {
@@ -10686,7 +11424,8 @@ function* projectJavaScriptSemanticFileSteps(file, ir, nodeBudget, paths = []) {
 		relations: [...state.relations.values()],
 		unknowns: [...state.unknowns.values()],
 		fingerprints,
-		truncated: Boolean(state.fileNodesDropped)
+		...state.unknownOmissions.size > 0 ? { omittedUnknownOccurrences: [...state.unknownOmissions.values()] } : {},
+		nodesTruncated: Boolean(state.fileNodesDropped)
 	};
 }
 function* projectFileSteps(file, ir, state, paths = []) {
@@ -10700,6 +11439,12 @@ function* projectFileSteps(file, ir, state, paths = []) {
 	});
 	if (moduleNode === null) return [];
 	state.roots.add(moduleNode.node_id);
+	projectFileResourceLimits({
+		file,
+		ir,
+		state,
+		moduleNode
+	});
 	yield* projectElectronSemanticCallPaths(file, paths, state);
 	const callableNodes = new Map();
 	for (const [index, callable] of ir.callables.entries()) {
@@ -10844,7 +11589,7 @@ function* projectDefinitionsAndReferences(context) {
 		});
 	}
 }
-var SEMANTIC_GRAPH_NODE_CEILING, SEMANTIC_GRAPH_FILE_NODE_CEILING, buildJavaScriptSemanticGraph, createJavaScriptSemanticGraphProjection, projectCalls, createArgumentNode, FILE_PROJECTION_PASSES;
+var SEMANTIC_GRAPH_NODE_CEILING, SEMANTIC_GRAPH_FILE_NODE_CEILING, buildJavaScriptSemanticGraph, createJavaScriptSemanticGraphProjection, projectFileResourceLimits, projectCalls, createArgumentNode, FILE_PROJECTION_PASSES;
 function init_JavaScriptSemanticGraphBuilder() {
 	return (init_JavaScriptSemanticGraphBuilder = __esmMin((() => {
 		init_javascriptSemanticGraph();
@@ -10857,6 +11602,8 @@ function init_JavaScriptSemanticGraphBuilder() {
 		init_JavaScriptSemanticGraphObjectProjection();
 		init_JavaScriptSemanticGraphValueProjection();
 		init_JavaScriptSemanticGraphEvidence();
+		init_javascriptSemanticCoverage();
+		init_javascriptSemanticResourceLimits();
 		init_javascriptApplicationEvidenceSchemas();
 		init_javascriptAnalysisResourceControls();
 		init_JavaScriptSemanticGraphFingerprintProjection();
@@ -10877,7 +11624,14 @@ function init_JavaScriptSemanticGraphBuilder() {
 		createJavaScriptSemanticGraphProjection = (limits = {}) => {
 			const nodeCeiling = limits.totalNodes ?? SEMANTIC_GRAPH_NODE_CEILING;
 			const fileNodeCeiling = limits.fileNodes ?? SEMANTIC_GRAPH_FILE_NODE_CEILING;
-			for (const value of [nodeCeiling, fileNodeCeiling]) if (!Number.isSafeInteger(value) || value < 1 || value > 1e6) throw new RangeError("Semantic graph requires valid node capacities");
+			const unknownCeiling = limits.totalUnknowns ?? JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS.semanticUnknowns;
+			const fileUnknownCeiling = limits.fileUnknowns ?? JAVASCRIPT_ANALYSIS_RESOURCE_DEFAULTS.semanticUnknownsPerFile;
+			for (const value of [
+				nodeCeiling,
+				fileNodeCeiling,
+				unknownCeiling,
+				fileUnknownCeiling
+			]) if (!Number.isSafeInteger(value) || value < 1 || value > 1e6) throw new RangeError("Semantic graph requires valid retained capacities");
 			const state = createSemanticGraphProjectionState();
 			const fingerprints = [];
 			let truncatedFiles = 0;
@@ -10892,15 +11646,19 @@ function init_JavaScriptSemanticGraphBuilder() {
 				const remainingTreeBudget = nodeCeiling - state.nodes.size;
 				state.fileNodeBudget = Math.min(fileNodeCeiling, remainingTreeBudget);
 				state.fileNodesDropped = false;
+				state.unknownCapacity = Math.min(unknownCeiling, state.unknowns.size + fileUnknownCeiling);
 				fingerprints.push(...yield* projectFileSteps(file, ir, state, paths));
 				if (state.fileNodesDropped) truncatedFiles += 1;
 				state.fileNodeBudget = null;
+				state.unknownCapacity = null;
 			};
 			const finishWith = (factory, rootArtifactSha256, applicationGraph) => {
 				bindSemanticGraphApplicationNodes(state, applicationGraph);
 				if (state.roots.size === 0) addSemanticFallbackRoot(rootArtifactSha256, state);
 				const relations = [...state.relations.values()];
 				const unknowns = [...state.unknowns.values()];
+				const unknownOmissions = [...state.unknownOmissions.values()];
+				const unknownsDropped = unknownOmissions.length > 0;
 				const retainedByFamily = new Map();
 				const unknownIdsByFamily = new Map();
 				for (const relation of relations) {
@@ -10923,19 +11681,32 @@ function init_JavaScriptSemanticGraphBuilder() {
 					fingerprints: [...fingerprints],
 					unknowns,
 					coverage: {
-						status: truncatedFiles > 0 || unavailableFiles > 0 ? "partial" : "unknown",
-						truncated: truncatedFiles > 0 || resourceTruncatedFiles > 0,
+						status: truncatedFiles > 0 || unavailableFiles > 0 || unknownsDropped ? "partial" : "unknown",
+						truncated: truncatedFiles > 0 || resourceTruncatedFiles > 0 || unknownsDropped,
+						...unknownsDropped ? { omitted_unknown_occurrences: unknownOmissions } : {},
 						omitted_nodes: truncatedFiles > 0 || unavailableFiles > 0 ? null : 0,
 						omitted_relations: truncatedFiles > 0 || unavailableFiles > 0 ? null : 0,
-						limits: [...executionLimits.values(), ...truncatedFiles > 0 ? [{
-							name: "semantic_graph_node_ceiling",
-							value: nodeCeiling,
-							unit: "items"
-						}, {
-							name: "semantic_graph_file_node_ceiling",
-							value: fileNodeCeiling,
-							unit: "items"
-						}] : []],
+						limits: [
+							...executionLimits.values(),
+							...unknownsDropped ? [{
+								name: "semantic_graph_unknown_ceiling",
+								value: unknownCeiling,
+								unit: "items"
+							}, {
+								name: "semantic_graph_file_unknown_ceiling",
+								value: fileUnknownCeiling,
+								unit: "items"
+							}] : [],
+							...truncatedFiles > 0 ? [{
+								name: "semantic_graph_node_ceiling",
+								value: nodeCeiling,
+								unit: "items"
+							}, {
+								name: "semantic_graph_file_node_ceiling",
+								value: fileNodeCeiling,
+								unit: "items"
+							}] : []
+						],
 						families: JAVASCRIPT_SEMANTIC_RELATION_FAMILIES.map((family) => ({
 							family,
 							status: semanticFamilyStatus(family),
@@ -10945,6 +11716,7 @@ function init_JavaScriptSemanticGraphBuilder() {
 						}))
 					},
 					limitations: [
+						...unknownsDropped ? ["Semantic unknown retention reached an effective capacity. Omission coverage counts examined emission occurrences by family and reason, including repeats; it does not count unexamined source frontiers or distinct discarded identities."] : [],
 						"The semantic graph contains static syntax observations and conservative relationship candidates; it does not claim runtime execution.",
 						"Local data flow does not claim control-flow-sensitive reaching definitions or arbitrary dynamic property resolution.",
 						"Promise ownership covers explicit unshadowed Promise construction, static factories, aggregation, chaining, and await syntax only.",
@@ -10961,25 +11733,33 @@ function init_JavaScriptSemanticGraphBuilder() {
 				state.nodes.clear();
 				state.relations.clear();
 				state.unknowns.clear();
+				state.unknownOmissions.clear();
 				state.roots.clear();
 				state.evidenceContexts.clear();
 				fingerprints.length = 0;
 				return graph;
 			};
 			return {
-				remainingFileNodeBudget: () => Math.min(fileNodeCeiling, Math.max(0, nodeCeiling - state.nodes.size)),
+				remainingFileCapacity: () => ({
+					nodes: Math.min(fileNodeCeiling, Math.max(0, nodeCeiling - state.nodes.size)),
+					unknowns: Math.min(fileUnknownCeiling, Math.max(0, unknownCeiling - state.unknowns.size))
+				}),
 				adoptFileProjection: (projection) => {
 					const newNodes = projection.nodes.filter(({ node_id }) => !state.nodes.has(node_id));
 					if (newNodes.length > Math.min(fileNodeCeiling, nodeCeiling - state.nodes.size)) throw new RangeError("Transferred semantic nodes exceed the offered tree capacity");
+					const newUnknowns = projection.unknowns.filter(({ unknown_id }) => !state.unknowns.has(unknown_id));
+					if (newUnknowns.length > Math.min(fileUnknownCeiling, unknownCeiling - state.unknowns.size)) throw new RangeError("Transferred semantic unknowns exceed the offered tree capacity");
+					for (const omission of projection.omittedUnknownOccurrences ?? []) recordSemanticUnknownOmission(state, omission);
 					for (const context of projection.evidenceContexts) state.evidenceContexts.adopt(context);
 					for (const node of newNodes) state.nodes.set(node.node_id, node);
 					for (const relation of projection.relations) state.relations.set(relation.relation_id, relation);
-					for (const unknown of projection.unknowns) state.unknowns.set(unknown.unknown_id, unknown);
+					for (const unknown of newUnknowns) state.unknowns.set(unknown.unknown_id, unknown);
 					for (const root of projection.roots) state.roots.add(root);
 					fingerprints.push(...projection.fingerprints);
-					if (projection.truncated) truncatedFiles += 1;
+					if (projection.nodesTruncated) truncatedFiles += 1;
 				},
 				recordUnavailableFile: (file, reason, limits, unknownReason) => {
+					if (file.kind !== "javascript") return;
 					const retainedLimits = javaScriptAnalysisCoverageLimits(limits);
 					for (const limit of retainedLimits) {
 						executionLimits.set(JSON.stringify([
@@ -11006,8 +11786,9 @@ function init_JavaScriptSemanticGraphBuilder() {
 						coverage: partialApplicationCoverage(retainedLimits, null),
 						limitations: [reason]
 					};
+					state.unknownCapacity = Math.min(unknownCeiling, state.unknowns.size + fileUnknownCeiling);
 					for (const family of JAVASCRIPT_SEMANTIC_RELATION_FAMILIES) {
-						const unknown = createJavaScriptSemanticGraphUnknown({
+						addSemanticGraphUnknown(state, {
 							node_id: module?.node_id ?? null,
 							family,
 							relation_kinds: JAVASCRIPT_SEMANTIC_RELATIONS.filter((relation) => JAVASCRIPT_SEMANTIC_RELATION_FAMILY[relation] === family),
@@ -11015,9 +11796,9 @@ function init_JavaScriptSemanticGraphBuilder() {
 							detail: reason,
 							candidate_node_ids: [],
 							evidence
-						}, state.evidenceContexts);
-						state.unknowns.set(unknown.unknown_id, unknown);
+						});
 					}
+					state.unknownCapacity = null;
 					unavailableFiles += 1;
 					if (unknownReason === "resource-limit" && retainedLimits.length > 0) resourceTruncatedFiles += 1;
 				},
@@ -11030,6 +11811,24 @@ function init_JavaScriptSemanticGraphBuilder() {
 				finishImmutableSteps: (rootArtifactSha256, applicationGraph) => finishWith(sealTransferredJavaScriptSemanticGraphSteps, rootArtifactSha256, applicationGraph)
 			};
 		};
+		projectFileResourceLimits = (context) => {
+			for (const limit of semanticCoverageResourceLimits(context.ir.coverage)) {
+				if (limit !== "getter-expansion") continue;
+				addSemanticGraphUnknown(context.state, {
+					node_id: context.moduleNode.node_id,
+					family: "data-flow",
+					relation_kinds: ["defines"],
+					reason: "resource-limit",
+					detail: semanticResourceLimitReason(limit),
+					candidate_node_ids: [],
+					evidence: {
+						...unknownSemanticEvidence(context.file, null),
+						coverage: partialApplicationCoverage(semanticResourceLimitCoverage([limit]), null),
+						limitations: [semanticResourceLimitReason(limit)]
+					}
+				});
+			}
+		};
 		projectCalls = (context) => {
 			for (const call of context.ir.callSites) {
 				const callNode = context.callSiteNodes.get(call.callSiteId);
@@ -11116,6 +11915,7 @@ function init_JavaScriptArtifactReconstruction() {
 		init_analysisErrorBase();
 		init_artifactOperationError();
 		init_JavaScriptArtifactAnalysis();
+		init_JavaScriptArtifactAnalysisTypes();
 		init_JavaScriptSourceAnalysis();
 		init_javascriptAnalysisResourceControls();
 		init_JavaScriptApplicationEvidence();
@@ -11163,8 +11963,10 @@ function init_JavaScriptArtifactReconstruction() {
 					kind: "artifact-inventory",
 					inventory: snapshot
 				});
-				await reportPhase("parse_javascript_sources", `Parsing and projecting ${String(files.files.length - (files.source_selection?.unselected_files ?? 0))} selected application source files`);
+				await reportPhase("parse_javascript_sources", `Processing ${String(files.files.length - (files.source_selection?.unselected_files ?? 0))} selected application files`);
 				const semanticProjection = createJavaScriptSemanticGraphProjection({
+					...input.max_semantic_unknowns === undefined ? {} : { totalUnknowns: input.max_semantic_unknowns },
+					...input.max_semantic_unknowns_per_file === undefined ? {} : { fileUnknowns: input.max_semantic_unknowns_per_file },
 					...input.max_semantic_nodes === undefined ? {} : { totalNodes: input.max_semantic_nodes },
 					...input.max_semantic_nodes_per_file === undefined ? {} : { fileNodes: input.max_semantic_nodes_per_file }
 				});
@@ -11177,11 +11979,12 @@ function init_JavaScriptArtifactReconstruction() {
 				try {
 					outcome = await analyzeAndAdoptJavaScriptArtifactFiles(files, worker, semanticProjection, async (file, completed, total) => {
 						abortIfNeeded(signal);
+						const ast = javascriptArtifactAnalysisScopes[file.kind]?.authority === "ast-static-analysis";
 						await progress?.report({
-							phase: "parse_javascript_source",
+							phase: ast ? "parse_javascript_source" : "process_javascript_artifact_metadata",
 							completed: 0,
 							total: 1,
-							message: `Parsing and projecting ${file.path} (${String(completed + 1)}/${String(total)})`
+							message: `${ast ? "Parsing and projecting" : "Processing metadata for"} ${file.path} (${String(completed + 1)}/${String(total)})`
 						});
 						abortIfNeeded(signal);
 					}, signal);
@@ -11240,6 +12043,7 @@ function init_JavaScriptArtifactReconstruction() {
 						text_bytes_read: files.text_bytes_read,
 						invalid_utf8_files: files.invalid_utf8_files,
 						parsed_javascript_files: analysis.files.filter(({ javascript }) => javascript !== null).length,
+						skipped_javascript_files: analysis.files.filter(isSkippedJavaScriptAnalysis).length,
 						visited_ast_nodes: analysis.visited_ast_nodes,
 						findings: analysis.findings,
 						modules: analysis.modules,