fix(javascript): resolve module-level Electron options in functions (#8960)

* fix(javascript): resolve module-level Electron options in functions

* fix(javascript): limit module option ancestry walk

* fix(javascript): preserve uncertain captured argument ordering

* fix(javascript): retain hoisted activation uncertainty

* fix(javascript): retain function ownership through loops

* fix(javascript): account for classic global activations

* fix(javascript): bind first activations to lexical identities

* fix(javascript): retain uncertain global activation timing

* fix(javascript): isolate receiver facts and share computed reads

* fix(javascript): retain projected and opaque global activations

* fix(javascript): refresh activation bounds as opaque effects grow

* fix(ci): format website watch directories without changing configuration

* fix(javascript): share source reads across opaque-effect updates

* fix(javascript): retain constructed-code global activation bounds

* fix(javascript): share runtime activation and receiver facts

* fix(javascript): reuse pattern reads and function positions

* fix(javascript): isolate copied paths and preserve runtime reads

* style(javascript): format migrated reference imports

* fix(javascript): normalize constructor activation and receiver effects

* fix(javascript): retain aliased receiver timing and lexical global this

* fix(javascript): preserve effect-free receiver identity across activations

* fix(javascript): retain outer activation and prototype effects

* fix(javascript): index implicit reads without deep path rescans

* fix(javascript): retain aliased prototype and parameter read uncertainty

* fix(javascript): index reflected reads through intrinsic invocation facts

* fix(javascript): retain unresolved global activation reads

* chore: refresh PR branch after review fix publication

* fix(javascript): retain projected receiver reads and cache method facts

* fix(javascript): retain inherited and implicit activation reads

* fix(javascript): retain caller-owned this uncertainty

* fix(javascript): retain reflected reads with unresolved spread arguments

* fix(javascript): preserve enclosing activation for decorators

* fix(javascript): track intrinsic literal prototype effects

* fix(javascript): retain catch activation from implicit reads

* perf(javascript): reuse effective keys for projected reads

* fix(javascript): retain possible caller-owned ambient effects

src/domain/javascript/javascriptSourceParser.test.ts

@@ -7,9 +7,43 @@ import {
   parserPluginsForPath,
   javaScriptRuntimeContext,
   javaScriptProgramStrictness,
+  javaScriptTopLevelThisMayBeGlobal,
 } from "./javascriptSourceParser.js";
+import { traverseJavaScriptAst } from "./javascriptSemanticTraversal.js";
 import { analyzeParsedJavaScriptStaticSource } from "./javascriptStaticAnalysis.js";
 
+it.each([
+  ["class C extends (this.marker, Object) {}", true],
+  ["class C { [this.marker]() {} }", true],
+  ["class C { [this.marker] = 1 }", true],
+  ["({[this.marker]() {}})", true],
+  ["class C { value = this.marker }", false],
+  ["class C { static value = this.marker }", false],
+  ["class C { static { this.marker } }", false],
+  ["class C { method() { this.marker } }", false],
+  ["function f() { return class C extends (this.marker, Object) {} }", false],
+  ["class C { value = class D { [this.marker]() {} } }", false],
+  ["(() => class C { [this.marker]() {} })()", true],
+] as const)(
+  "owns definition-time this separately from class bodies: %s",
+  (source, expected) => {
+    const parsed = parseJavaScriptSource(source);
+    if (parsed === null) throw new Error("Expected parsed fixture");
+    const parents = new WeakMap<t.Node, t.Node>();
+    let selected: t.ThisExpression | undefined;
+    traverseJavaScriptAst(parsed.program, {
+      enter(node, parent) {
+        if (parent !== null) parents.set(node, parent);
+        if (t.isThisExpression(node)) selected = node;
+      },
+    });
+    if (selected === undefined) throw new Error("Missing this fixture");
+    expect(
+      javaScriptTopLevelThisMayBeGlobal(selected, parsed.program, parents),
+    ).toBe(expected);
+  },
+);
+
 it.each([
   ['import type {T} from "example";', "fixture.cts", "commonjs"],
   ['import type {T} from "example";', "fixture.mts", "module"],