fix(target-react): stabilize member-mutated top-level <script> consts (useMemo)

A top-level `const X = new Set()` (or `[]`/`{}`) that is member-mutated as
cross-render scratch state but referenced only from a plain function — never
escaping into a useEffect dep — was emitted INLINE, so React re-created it
every render and silently reset the state. On the 5 setup-once targets the
`<script>` runs once, so the instance persists; React's re-running component
body broke the setup-once contract.

This is the root cause of the `code-mirror [react]` VR Matrix hang (red on
main since the CodeMirror G5 wave-2 batch b429107..df5f6aa): CodeMirrorDemo's
`const gutterSeen = new Set()` dedupe guard reset every render → the
`:data-cap="markGutterMount(line)"` render side-effect always re-incremented
`$data` → re-render → reconfigure → portal flushSync → infinite loop → 30s
timeout → the React demo never committed → the counted A/B editors never
appeared.

Fix: extend the React emitter with the const-analog of the reassigned-`let`→
`useRef` hoist. `collectMutatedInstanceBinders` finds top-level const/let
binders whose init is a fresh mutable instance (`new`/array/object literal) AND
which are member-mutated (`.add`/`.set`/`.push`/`.delete`/`X[k]=…`/`X.f++`/
`delete X[k]`); `tryWrapMutatedInstanceUseMemo` wraps each in
`useMemo(() => init, [])` so it is built once per instance. useMemo keeps the
binder name, so reads/mutations need no `.current` rewrite. Runs before the
escaping-const useMemo wrap so a binder that is both escaping and mutated gets
the stable `[]` identity (mutable state must never be re-created).

Conservative: a pure derived `const total = a + b` is never a fresh-instance
init and never member-mutated, so it is never frozen; reassigned `let`s are
excluded (that is the hoistModuleLet→useRef case). Member-mutated consts that
already escaped into a mount effect (e.g. MapLibre's marker/popup/feature Maps)
were already `useMemo(…, [])` via the escaping path — byte-identical output, no
drift.

Gates: minimal repro stabilizes seenConst while leaving pureDerived inline;
cold `--force` build 86/86 + typecheck 105/105 + test 64/64 (zero dist-parity /
snapshot drift — only React emit changes, only for the genuinely-non-escaping
case); Linux-Docker VR `code-mirror [react]` 3/3 green; full matrix 403 passed,
zero regressions.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: serpentblade

packages/targets/react/src/emit/emitScript.ts

@@ -478,6 +478,169 @@ function tryWrapEscapingConstUseMemo(
   return `const ${constName} = useMemo(${arrowBody(init)}, ${depsLiteral});`;
 }
 
+/**
+ * Member-mutating instance methods. A call `X.<m>(...)` where `<m>` is one of
+ * these MUTATES the instance `X` (rather than reading from it — `.has`/`.get`/
+ * `.map`/`.size` are reads and deliberately excluded). Used by
+ * `collectMutatedInstanceBinders` to distinguish a cross-render scratch binder
+ * (must persist) from a read-only one.
+ */
+const MUTATING_INSTANCE_METHODS = new Set<string>([
+  // Set / Map
+  'add', 'set', 'delete', 'clear',
+  // Array
+  'push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse', 'fill', 'copyWithin',
+]);
+
+/** A `new X()`, `[...]`, or `{...}` initializer — a freshly-built mutable instance. */
+function isFreshMutableInstanceInit(init: t.Expression): boolean {
+  return t.isNewExpression(init) || t.isArrayExpression(init) || t.isObjectExpression(init);
+}
+
+/** Root identifier name of a (possibly nested) MemberExpression: `X.a.b`/`X[k]` → `X`. */
+function memberRootName(node: t.Node): string | null {
+  let cur: t.Node = node;
+  while (t.isMemberExpression(cur) || t.isOptionalMemberExpression(cur)) {
+    cur = cur.object;
+  }
+  return t.isIdentifier(cur) ? cur.name : null;
+}
+
+/**
+ * Phase 35 follow-up (feedback_react_const_mutinstance_not_stabilized) —
+ * collect the names of top-level `const`/`let` binders whose initializer is a
+ * freshly-constructed MUTABLE INSTANCE (`new X()`, `[...]`, `{...}`) AND which
+ * are MEMBER-MUTATED somewhere in the component (`X.add(...)`, `X.set(...)`,
+ * `X.push(...)`, `X.delete(...)`, `X[k] = …`, `X.foo++`, `delete X[k]`).
+ *
+ * Such a binder is cross-render scratch state in the author's setup-once mental
+ * model: the 5 setup-once targets run `<script>` ONCE so the instance persists,
+ * but React re-runs the component body every render, re-creating the instance
+ * and silently resetting the state. CodeMirrorDemo's `const gutterSeen = new
+ * Set()` dedupe guard is the canonical case — re-created every render →
+ * `markGutterMount` always re-increments `$data` (the guard never deduplicates)
+ * → render side-effect → re-render → infinite loop → 30s VR hang. Wrapping the
+ * binder in `useMemo(() => init, [])` restores per-instance setup-once identity
+ * (the const-analog of the reassigned-`let`→`useRef` hoist in `hoistModuleLet`,
+ * but useMemo keeps the binder name so reads/mutations need no `.current`
+ * rewrite).
+ *
+ * Conservatism, two gates:
+ *   - init-shape: only `new`/array/object literals — a pure derived `const total
+ *     = a + b` is never a fresh-instance init, so it is never frozen.
+ *   - member-mutation: the binder must actually be mutated; a read-only fresh
+ *     instance is left alone (its identity churn is harmless).
+ *
+ * `let` binders that are also REASSIGNED (`X = …`, a bare-identifier write) are
+ * excluded — useMemo cannot model reassignment; those are the `hoistModuleLet`
+ * → `useRef` case (already handled when they escape into a lifecycle hook).
+ */
+function collectMutatedInstanceBinders(program: t.File): Set<string> {
+  // 1. Candidate binders: top-level single-name const/let with a fresh-instance init.
+  const candidates = new Set<string>();
+  for (const stmt of program.program.body) {
+    if (!t.isVariableDeclaration(stmt)) continue;
+    if (stmt.kind !== 'const' && stmt.kind !== 'let') continue;
+    for (const d of stmt.declarations) {
+      if (!t.isIdentifier(d.id)) continue;
+      if (!d.init) continue;
+      if (t.isArrowFunctionExpression(d.init) || t.isFunctionExpression(d.init)) continue;
+      if (!isFreshMutableInstanceInit(d.init)) continue;
+      candidates.add(d.id.name);
+    }
+  }
+  if (candidates.size === 0) return candidates;
+
+  // 2. Walk the whole program. Record member-mutations (→ mutated) and bare
+  //    reassignments (→ reassigned, which disqualify a `let`).
+  const mutated = new Set<string>();
+  const reassigned = new Set<string>();
+  traverse(program, {
+    AssignmentExpression(path) {
+      const left = path.node.left;
+      if (t.isIdentifier(left)) {
+        if (candidates.has(left.name)) reassigned.add(left.name);
+        return;
+      }
+      if (t.isMemberExpression(left)) {
+        const r = memberRootName(left);
+        if (r && candidates.has(r)) mutated.add(r);
+      }
+    },
+    UpdateExpression(path) {
+      const arg = path.node.argument;
+      if (t.isIdentifier(arg)) {
+        if (candidates.has(arg.name)) reassigned.add(arg.name);
+        return;
+      }
+      if (t.isMemberExpression(arg)) {
+        const r = memberRootName(arg);
+        if (r && candidates.has(r)) mutated.add(r);
+      }
+    },
+    UnaryExpression(path) {
+      if (path.node.operator !== 'delete') return;
+      const arg = path.node.argument;
+      if (t.isMemberExpression(arg)) {
+        const r = memberRootName(arg);
+        if (r && candidates.has(r)) mutated.add(r);
+      }
+    },
+    CallExpression(path) {
+      const callee = path.node.callee;
+      if (!t.isMemberExpression(callee) || callee.computed) return;
+      if (!t.isIdentifier(callee.property)) return;
+      if (!MUTATING_INSTANCE_METHODS.has(callee.property.name)) return;
+      if (!t.isIdentifier(callee.object)) return;
+      if (candidates.has(callee.object.name)) mutated.add(callee.object.name);
+    },
+  });
+
+  // Member-mutated AND not bare-reassigned (consts can never be reassigned).
+  const result = new Set<string>();
+  for (const name of mutated) {
+    if (!reassigned.has(name)) result.add(name);
+  }
+  return result;
+}
+
+/**
+ * Phase 35 follow-up — wrap a top-level member-mutated fresh-instance
+ * `const`/`let X = init` in `useMemo(() => init, [])` so the instance is built
+ * ONCE per component instance (setup-once parity). Companion detection lives in
+ * `collectMutatedInstanceBinders`. Returns the rendered line, or null when the
+ * binder isn't a stabilization target.
+ *
+ * Distinct from `tryWrapEscapingConstUseMemo`: that wraps a const that escapes
+ * into a useEffect dep array, keyed on its real reactive deps (`[...initDeps]`).
+ * This wraps cross-render MUTABLE STATE, which must NEVER be re-created — hence
+ * the empty `[]` dep array regardless of what the init reads (matching the
+ * setup-once targets, which capture init values once and never re-read them).
+ * Runs FIRST in the loop so a binder that is both escaping and mutated gets the
+ * stable `[]` identity.
+ */
+function tryWrapMutatedInstanceUseMemo(
+  stmt: t.Statement,
+  mutatedInstanceNames: ReadonlySet<string>,
+  collectors: { react: ReactImportCollector; runtime: RuntimeReactImportCollector },
+): string | null {
+  if (!t.isVariableDeclaration(stmt)) return null;
+  if (stmt.kind !== 'const' && stmt.kind !== 'let') return null;
+  if (stmt.declarations.length !== 1) return null;
+  const decl = stmt.declarations[0]!;
+  if (!t.isIdentifier(decl.id)) return null;
+  const init = decl.init;
+  if (!init) return null;
+  if (t.isArrowFunctionExpression(init) || t.isFunctionExpression(init)) return null;
+  if (!mutatedInstanceNames.has(decl.id.name)) return null;
+
+  collectors.react.add('useMemo');
+  // Preserve an author declarator annotation (`const seen: Set<string> = …`):
+  // `useMemo(() => new Set(), [])` would otherwise infer `Set<unknown>`.
+  const declTypeSuffix = renderDeclaratorTypeSuffix(decl.id);
+  return `const ${decl.id.name}${declTypeSuffix} = useMemo(${arrowBody(init)}, []);`;
+}
+
 /**
  * Find all distinct `props.onX` names that appear in CALL position inside
  * `body`. Returns the set of names (without the `on` prefix? no — keep raw
@@ -2459,6 +2622,14 @@ export function emitScript(
     }
   }
 
+  // 6a'. Phase 35 follow-up (feedback_react_const_mutinstance_not_stabilized) —
+  // collect top-level fresh-instance const/let binders that are member-mutated
+  // (cross-render scratch state, e.g. CodeMirrorDemo's `const gutterSeen = new
+  // Set()` dedupe guard). These must persist per-instance like the setup-once
+  // targets; without stabilization React re-creates them every render and the
+  // guard resets → render side-effects re-fire → infinite re-render → VR hang.
+  const mutatedInstanceNames = collectMutatedInstanceBinders(cloned);
+
   // 6b. Helper-name pre-scan (`allHelperNames` / `helperLocByName`) is built
   // earlier — hoisted above the lifecycle + watcher loops in Round 4 of
   // 260519 linechart-watch-recreate so the watcher loop's callback-body walk
@@ -2547,6 +2718,21 @@ export function emitScript(
       }
     }
 
+    // Phase 35 follow-up — member-mutated fresh-instance binder → useMemo(()=>init,[]).
+    // Runs FIRST so a binder that is BOTH escaping and mutated gets the stable
+    // `[]` identity (cross-render mutable state must never be re-created),
+    // rather than the reactive-deps `[...]` from tryWrapEscapingConstUseMemo.
+    const mutMemoWrapped = tryWrapMutatedInstanceUseMemo(
+      stmt,
+      mutatedInstanceNames,
+      collectors,
+    );
+    if (mutMemoWrapped) {
+      userArrowsLines.push(mutMemoWrapped);
+      // String output (like the other wraps) — excluded from mappableStmts.
+      continue;
+    }
+
     // Try the useCallback escape-wrap first; falls back to function-decl
     // hoist if the helper isn't escaping.
     const wrapped = tryWrapEscapingHelperUseCallback(