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
2026-11-11 01:13:39 +00:00 · 2026-10-20 17:25:19 +08:00
1 parent d532b18123
commit e9fc8fb30c
@@ -0,0 +1,126 @@
+import type { JavaScriptSemanticPropertyPath } from "./javascriptSemanticPropertyPaths.js";
+import { SEMANTIC_ALIAS_SELECTION_LIMIT } from "./javascriptSemanticResourceLimits.js";
+
+type PropertyKey = JavaScriptSemanticPropertyPath[number];
+
+/** Finite alternatives retain selected keys without admitting unrelated slots. */
+export type SemanticAliasSelection =
+  | PropertyKey
+  | { readonly alternatives: readonly PropertyKey[] };
+
+export type SemanticAliasSelectionPath = readonly SemanticAliasSelection[];
+
+export const semanticAliasSelectionChoices = (
+  key: SemanticAliasSelection,
+): readonly PropertyKey[] =>
+  key !== null && typeof key === "object" && "alternatives" in key
+    ? key.alternatives
+    : [key];
+
+const selection = (choices: readonly PropertyKey[]): SemanticAliasSelection => {
+  if (choices.includes(null)) return null;
+  const alternatives = [
+    ...new Map(choices.map((choice) => [JSON.stringify(choice), choice])),
+  ]
+    .sort(([left], [right]) => (left < right ? -1 : left > right ? 1 : 0))
+    .map(([, choice]) => choice);
+  return alternatives.length === 1 ? alternatives[0]! : { alternatives };
+};
+
+const selectionCovers = (
+  prior: SemanticAliasSelection,
+  next: SemanticAliasSelection,
+): boolean => {
+  if (prior === null) return true;
+  const choices = new Set(
+    semanticAliasSelectionChoices(prior).map((key) => JSON.stringify(key)),
+  );
+  return semanticAliasSelectionChoices(next).every((key) =>
+    choices.has(JSON.stringify(key)),
+  );
+};
+
+const pathCovers = (
+  prior: SemanticAliasSelectionPath,
+  next: SemanticAliasSelectionPath,
+): boolean =>
+  prior.every(
+    (key, index) =>
+      next[index] !== undefined && selectionCovers(key, next[index]!),
+  );
+
+/** Only one differing selector can be joined without inventing crossed paths. */
+const joinSelections = (
+  prior: SemanticAliasSelectionPath,
+  next: SemanticAliasSelectionPath,
+): SemanticAliasSelectionPath | undefined => {
+  let changed = -1;
+  for (let index = 0; index < prior.length; index++) {
+    if (JSON.stringify(prior[index]) === JSON.stringify(next[index])) continue;
+    if (changed !== -1) return undefined;
+    changed = index;
+  }
+  return prior.map((key, index) =>
+    index === changed
+      ? selection([
+          ...semanticAliasSelectionChoices(key),
+          ...semanticAliasSelectionChoices(next[index]!),
+        ])
+      : key,
+  );
+};
+
+/** Preserve correlated selector alternatives while coalescing complete grids. */
+export class SemanticAliasSelections {
+  #paths = new WeakMap<object, Map<number, SemanticAliasSelectionPath[]>>();
+  #calls = 0;
+  #limited = false;
+
+  constructor(readonly onLimit: () => void) {}
+
+  get limited(): boolean {
+    return this.#limited;
+  }
+
+  normalize(
+    node: object,
+    next: SemanticAliasSelectionPath,
+  ): SemanticAliasSelectionPath {
+    if (this.#limited) return next.map(() => null);
+    const existing = this.#paths.get(node);
+    const byDepth = existing ?? new Map<number, SemanticAliasSelectionPath[]>();
+    const paths = [...(byDepth.get(next.length) ?? [])];
+    let candidate = next.map((key) =>
+      selection(semanticAliasSelectionChoices(key)),
+    );
+    const covered = paths.find((prior) => pathCovers(prior, candidate));
+    if (covered !== undefined) return covered;
+    if (
+      existing !== undefined &&
+      ++this.#calls > SEMANTIC_ALIAS_SELECTION_LIMIT
+    ) {
+      this.#limited = true;
+      this.#paths = new WeakMap();
+      this.onLimit();
+      return next.map(() => null);
+    }
+    for (let index = 0; index < paths.length;) {
+      const prior = paths[index]!;
+      if (pathCovers(prior, candidate)) return prior;
+      const joined = pathCovers(candidate, prior)
+        ? candidate
+        : joinSelections(prior, candidate);
+      if (joined === undefined) {
+        index++;
+        continue;
+      }
+      candidate = [...joined];
+      paths.splice(index, 1);
+      index = 0;
+    }
+    paths.push(candidate);
+    byDepth.set(candidate.length, paths);
+    this.#paths.set(node, byDepth);
+    return candidate;
+  }
+}