fix(javascript): preserve runtime path bytes and Electron ownership (#4941)

* fix(javascript): preserve literal percent runtime paths

* fix(javascript): ignore resolve prefixes before the final anchor

* fix(electron): retain application roots for loadFile declarations

* fix(electron): resolve loadFile from enclosing application package

* fix(electron): retain outer application root across package scopes

* fix(electron): derive application ownership from inventoried packages

* fix(electron): retain resolved package entrypoint ownership

* fix(electron): preserve competing application ownership

* fix(electron): retain invalid and omitted runtime ownership

* fix(electron): preserve omitted module ownership and runtime paths

* fix(electron): preserve proven roots before confining page paths

* fix(electron): retain possible owners behind missing imports

* fix(electron): distinguish absent imports and owned page candidates

* fix(electron): keep unavailable JSON out of owner gaps

* fix(electron): retain exact loader formats and default entry status

* fix(electron): retain unavailable entrypoint ownership candidates

* test(ghidra): preserve Windows Node probe prerequisites

* test(ghidra): assert cancellation during profile shutdown

* fix(electron): separate examined imports from frontend ownership

* fix(electron): retain unavailable directory entrypoint owners

* test(jeb): retain Linux ownership prerequisite in isolation

* fix(javascript): retain unchecked loader ownership and literal main paths

* fix(javascript): preserve runtime paths and call-site module aliases

* fix(javascript): bound module alias traversal and preserve projections

* fix(javascript): retain host module and nested artifact path boundaries

* fix(javascript): preserve ESM and archive module loader provenance

* test(javascript): distinguish unmapped containers from missing exports

* fix: retain default module aliases and Electron builtin imports

* fix: preserve host file URL and inward ASAR ownership

* fix: preserve CommonJS file URL classification in CI fixtures

* fix: retain bound module loaders and Windows entrypoint uncertainty

* fix: retain ASAR uncertainty and invalidate changed Electron app roots

* fix(javascript): retain ownership uncertainty across loader boundaries

* fix(javascript): preserve loader sources and bound alias queries

* fix(javascript): retain destructured loader sources

* fix(javascript): preserve loader uncertainty at resolution boundaries

* fix(javascript): preserve callable and package launch ownership

* fix(javascript): preserve captured values across member reads

* test(process): assert tagged filesystem cancellation failures

* fix(javascript): preserve inventory bases and invocation read timing

* fix(javascript): preserve ownership across indirect and unread loads

* test(javascript): order fixture directory creation on Windows

* test(javascript): share ordered filesystem fixture writer

* fix(javascript): unify loader provenance and package validation

* fix(javascript): preserve captured Node require loader values

* fix(javascript): preserve loader invocation authority

* fix(javascript): verify generic loader invocation authority

* fix(javascript): preserve conditional loader method alternatives

* fix(javascript): require proven factories for source association

* fix(javascript): honor replaced Electron app path setters

* fix(javascript): prove path and assignment source ownership

* fix(javascript): retain native delegate eligibility through shared writes

* fix(process): settle stale baseline errors after confirmed absence

* fix(javascript): preserve assignment and path boundary evidence

* fix(javascript): prove source-directory resolve anchors

* fix: preserve application path provenance and portable schemas

* fix(javascript): retain CommonJS exported setter effects

* fix: isolate Linux identity observations and retain native module exports

* fix(javascript): preserve published app and helper provenance

* fix(javascript): normalize typed stores and native path fixtures

src/domain/javascript/javascriptSemanticValues.ts

@@ -63,6 +63,27 @@ import {
   semanticResourceLimitReason,
 } from "./javascriptSemanticResourceLimits.js";
 
+// Function identity is outside the public constant lattice. Retain its
+// non-undefined proof with the immutable value rather than interpreting an
+// "unknown" reason or recovering callable syntax in default consumers.
+const definitelyDefinedValues = new WeakSet<JavaScriptSemanticValue>();
+
+const definedNonPrimitiveValue = (reason: string): JavaScriptSemanticValue => {
+  const value: JavaScriptSemanticValue = { status: "unknown", reason };
+  definitelyDefinedValues.add(value);
+  return value;
+};
+
+/** Definedness is independent of whether the constant lattice retains a value. */
+export const semanticValueDefinitelyDefined = (
+  value: JavaScriptSemanticValue,
+): boolean =>
+  value.status === "literal" ||
+  value.status === "union" ||
+  value.status === "object" ||
+  value.status === "array" ||
+  definitelyDefinedValues.has(value);
+
 interface MemoizedEvaluation<T> {
   readonly value: T;
   readonly dependencies: SemanticDependencyProof;
@@ -433,6 +454,16 @@ const evaluateBinding = (
     const reusable = readMemoizedEvaluation(retained, context);
     if (reusable !== undefined) return reusable;
   }
+  if (
+    binding.referenceInitializers.some(({ assignment }) => assignment) &&
+    (binding.initializers.length > 0 ||
+      (context.state.bindingsById.get(binding.bindingId)?.initializers.length ??
+        0) > 0)
+  )
+    return {
+      status: "ambiguous",
+      reason: `Binding ${binding.name} has value and projected-reference assignments.`,
+    };
   if (binding.initializers.length === 0)
     return {
       status: "unknown",
@@ -615,6 +646,14 @@ const evaluateExpressionValue = (
   }
   const literal = readExactJavaScriptLiteral(node);
   if (literal.found) return primitiveSet([literal.value]);
+  if (
+    t.isFunctionExpression(node) ||
+    t.isFunctionDeclaration(node) ||
+    t.isArrowFunctionExpression(node) ||
+    t.isClassExpression(node) ||
+    t.isClassDeclaration(node)
+  )
+    return definedNonPrimitiveValue(`Unsupported ${node.type} value.`);
   if (t.isIdentifier(node)) {
     const binding = resolveSemanticBindingState(context.state, node, node.name);
     if (binding === undefined)
@@ -759,10 +798,14 @@ const evaluateObject = (
       presence: "present",
       value: t.isObjectProperty(property)
         ? evaluateCapturedExpression(property.value, nestedContext(context))
-        : {
-            status: "unknown",
-            reason: "Object method or accessor value is not a primitive.",
-          },
+        : property.kind === "method"
+          ? definedNonPrimitiveValue(
+              "Object method or accessor value is not a primitive.",
+            )
+          : {
+              status: "unknown",
+              reason: "Object method or accessor value is not a primitive.",
+            },
     });
   }
   const properties = [...propertiesByName.values()].sort((left, right) =>
@@ -1011,6 +1054,29 @@ const provenanceForBindingUncached = (
 const provenanceForBindingValue = (
   binding: JavaScriptSemanticBindingState,
   context: EvaluationContext,
+): JavaScriptBindingProvenance => {
+  const provenance = provenanceForBindingInitializers(binding, context);
+  if (!binding.referenceInitializers.some(({ assignment }) => assignment))
+    return provenance;
+  // Projected replacements are retained reference sources, not evidence of a
+  // local value or an unchanged earlier module. Apply this only to the selected
+  // read snapshot so a later replacement does not erase captured origins.
+  if (provenance.status === "local")
+    return semanticUnresolvedProvenance(
+      "unknown",
+      `Binding ${binding.name} has projected reference assignments whose module provenance is unresolved.`,
+    );
+  return provenance.status === "module"
+    ? semanticAmbiguousProvenance(
+        provenance.origins,
+        `Binding ${binding.name} has projected reference assignments that may replace its module origin.`,
+      )
+    : provenance;
+};
+
+const provenanceForBindingInitializers = (
+  binding: JavaScriptSemanticBindingState,
+  context: EvaluationContext,
 ): JavaScriptBindingProvenance => {
   if (binding.kind === "parameter" || binding.kind === "catch")
     return semanticUnresolvedProvenance(
@@ -1239,11 +1305,14 @@ const mergeValues = (
   const primitives = values.flatMap(
     (value) => primitiveCandidates(value) ?? [],
   );
-  return values.every(
+  const merged: JavaScriptSemanticValue = values.every(
     (value) => value.status === "union" || value.status === "literal",
   )
     ? primitiveSet(primitives)
     : { status: "ambiguous", reason: "Branches have incompatible values." };
+  if (values.length > 0 && values.every(semanticValueDefinitelyDefined))
+    definitelyDefinedValues.add(merged);
+  return merged;
 };
 
 const nestedContext = (context: EvaluationContext): EvaluationContext => ({