@barefootjs/jsx 0.31.9 → 0.32.0

package/src/ssr-defaults.ts

@@ -30,6 +30,7 @@
 // `undef`, which Mojo renders as empty string).
 
 import ts from 'typescript'
+import { extractFreeIdentifiersFromNode } from './analyzer.ts'
 import type { IRMetadata } from './types.ts'
 
 /**
@@ -52,6 +53,16 @@ export interface SsrDefault {
    * (`{ variant = 'default' }`) where the template variable maps 1:1
    * to a caller-supplied prop. Omitted for signal / memo entries that
    * are internal to the component.
+   *
+   * Invariant (#2669): a signal / memo entry carries `propName` IF AND
+   * ONLY IF it's a self-derivation collision — the signal/memo's own
+   * template variable shares a name with the prop its initializer
+   * derives from (`const [label] = createSignal(props.label ?? 'x')`).
+   * Every OTHER signal/memo entry is `propName`-less. Consumers (e.g.
+   * every template-stash adapter's conformance harness, `test-render.ts`)
+   * rely on this to know a signal/memo's stash seed must defer to the
+   * already-derived prop value rather than re-seeding from its own
+   * evaluated initial — see `extractSsrDefaults`'s signal/memo loops.
    */
   propName?: string
   /**
@@ -204,6 +215,11 @@ export function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefa
   // fed into the bindings map so subsequent memos can reference earlier
   // signals (Counter's `doubled = createMemo(() => count() * 2)`).
   const bindings: Record<string, EvalResult> = {}
+  // Component-scope const locals, for the transitive prop-reference
+  // resolution both `referencesOwnProp` calls below and the bare-props
+  // safety net (further down) use — computed once so every caller shares
+  // the same table.
+  const localConsts = localConstValuesByName(metadata)
 
   // (#checkbox) Seed module-scope constants so a memo template-literal that
   // references them resolves to a concrete string. Checkbox's `classes` memo
@@ -225,14 +241,73 @@ export function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefa
     // baked initial value.
     if (sig.envReader) continue
     const value = tryStaticEval(sig.initialValue, { bindings, propsLike })
-    out[sig.getter] = { value: resultToJsonable(value) }
+    // Self-derivation collision (#2669): a signal whose getter shares its
+    // name with the prop its OWN initializer derives from
+    // (`const [label] = createSignal(props.label ?? 'Default')`) gets a
+    // template-stash variable that the emitted template both READS (as the
+    // raw caller prop) and OVERWRITES (with the derived signal value) under
+    // that SAME name — see the Mojo/Jinja/etc. emitter's `{% set label =
+    // (label if label is defined else 'Default') %}`. Seeding the stash
+    // with the DERIVED value here would either permanently lock out a
+    // caller-supplied prop (idempotent derivations like `?? 'Default'` hide
+    // this — a caller's real value can never win) or double-apply a
+    // non-idempotent derivation (`(props.count ?? 1) * 2` seeded with the
+    // evaluated `2` re-derives to `2 * 2 = 4`). The correct seed is the RAW
+    // prop, so the entry must be a PROP entry (`propName` set, `value:
+    // null`) instead of a plain signal-value entry — the template's own
+    // `?? <default>` / `is not none` guard performs the real derivation,
+    // exactly like the bare-props safety net below.
+    //
+    // NOT self-derived (the initializer references a DIFFERENT prop, or no
+    // prop at all) keeps today's behavior: the signal's evaluated value
+    // wins the entry outright. This also correctly leaves alone the
+    // separate (out-of-scope) case where the signal's OWN initializer does
+    // NOT reference the same-named prop but the JSX body separately reads
+    // both `label()` and `props.label` — that's a template-variable-
+    // aliasing defect, not this one, and must render byte-identically.
+    //
+    // Invariant this establishes (relied on by every template-stash
+    // conformance harness's seeding loops — see `test-render.ts`): a
+    // signal/memo entry carries `propName` IF AND ONLY IF it went through
+    // this collision path. An ordinary signal/memo entry never has
+    // `propName` — that's exclusively how a harness (or a production
+    // manifest consumer) can tell "this local's stash seed must come from
+    // the caller-facing prop, not the local's own evaluated value" apart
+    // from "this is an internal signal/memo the caller cannot override".
+    if (metadata.propsObjectName !== null && referencesOwnProp(sig.initialValue, metadata.propsObjectName, sig.getter, localConsts)) {
+      // Pass 1 above already wrote the prop entry when the prop is
+      // *declared* on the props type — leave it as-is. An undeclared
+      // (untyped / inline-typed) prop has no pass-1 entry yet; create it
+      // here so the collision is still resolved for that shape.
+      if (!(sig.getter in out)) {
+        out[sig.getter] = { propName: sig.getter, value: null }
+      }
+    } else {
+      out[sig.getter] = { value: resultToJsonable(value) }
+    }
+    // `bindings` always gets the EVALUATED value regardless of which stash
+    // seed the entry above ended up with — a later memo referencing this
+    // getter (`createMemo(() => label() + '!')`) must keep resolving
+    // through the chain exactly as before; only the manifest's own seed
+    // choice changes, not the static-eval semantics.
     bindings[sig.getter] = value
   }
 
   for (const memo of metadata.memos) {
     if (memo.isModule) continue
     const value = tryStaticEval(memo.computation, { bindings, propsLike })
-    out[memo.name] = { value: resultToJsonable(value) }
+    // Same self-derivation collision as signals above, for a memo whose
+    // computation derives from a same-named prop
+    // (`createMemo(() => (props.label ?? 'Default') + n())`). See the
+    // signal loop's comment for the full mechanism and the `propName`
+    // invariant this relies on.
+    if (metadata.propsObjectName !== null && referencesOwnProp(memo.computation, metadata.propsObjectName, memo.name, localConsts)) {
+      if (!(memo.name in out)) {
+        out[memo.name] = { propName: memo.name, value: null }
+      }
+    } else {
+      out[memo.name] = { value: resultToJsonable(value) }
+    }
     bindings[memo.name] = value
   }
 
@@ -251,11 +326,11 @@ export function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefa
     const referenced = new Set<string>()
     for (const sig of metadata.signals) {
       if (!sig.getter || sig.isModule || sig.envReader) continue
-      collectPropRefs(sig.initialValue, metadata.propsObjectName, referenced)
+      collectPropRefsTransitive(sig.initialValue, metadata.propsObjectName, localConsts, referenced)
     }
     for (const memo of metadata.memos) {
       if (memo.isModule) continue
-      collectPropRefs(memo.computation, metadata.propsObjectName, referenced)
+      collectPropRefsTransitive(memo.computation, metadata.propsObjectName, localConsts, referenced)
     }
     for (const name of referenced) {
       // Don't clobber a signal / memo (or already-seeded prop) of the same
@@ -268,6 +343,47 @@ export function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefa
   return Object.keys(out).length === 0 ? undefined : out
 }
 
+/**
+ * Component-scope (non-module) `const` locals, by name → value source text.
+ * `referencesOwnProp` and `collectPropRefsTransitive` (below) use this to
+ * see PAST one hop of pure indirection between a prop read and the
+ * signal/memo that derives from it — `const mid = props.label;
+ * createSignal(mid ?? 'Default')` (#2685 review, one hop past #2669's
+ * direct-access-only detection). Module-scope consts are excluded: a
+ * MODULE const's value is fixed at compile time and isn't a `props.X` read
+ * (a module const referencing `props` isn't legal JS — `props` is a
+ * function parameter), so it can never contribute a prop reference here.
+ */
+function localConstValuesByName(metadata: IRMetadata): ReadonlyMap<string, string> {
+  const out = new Map<string, string>()
+  for (const c of metadata.localConstants ?? []) {
+    if (c.isModule || c.value === undefined) continue
+    out.set(c.name, c.value)
+  }
+  return out
+}
+
+/**
+ * Does `expr` (a signal initializer or memo computation) read
+ * `propsObjectName.<name>` where `name` is that SAME signal's getter / that
+ * SAME memo's name — directly, or through a chain of component-scope
+ * `const` locals? This is the #2669 self-derivation test (widened by
+ * #2685 review to see through indirection): reuses `collectPropRefsTransitive`
+ * (never a bespoke walker — see the CLAUDE.md rule this file already
+ * follows for `props.X` collection) and just checks membership of the one
+ * name we care about.
+ */
+function referencesOwnProp(
+  expr: string | undefined,
+  propsObjectName: string,
+  name: string,
+  localConsts: ReadonlyMap<string, string>,
+): boolean {
+  const referenced = new Set<string>()
+  collectPropRefsTransitive(expr, propsObjectName, localConsts, referenced)
+  return referenced.has(name)
+}
+
 /**
  * Collect the first-level property name of every `propsObjectName.X` access
  * within `expr` (e.g. `props.initial ?? 0` → `initial`). Used to seed the
@@ -276,6 +392,11 @@ export function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefa
  * prop `a`: adapters lower that to `$a->{b}`, so the bare `$a` needs
  * seeding just the same — the walk stops at the first
  * `propsObjectName.<name>` match and collects `a` (not `b`).
+ *
+ * Direct-access only — does NOT look through a component-scope `const`
+ * that itself reads `propsObjectName.X`. Callers that need to see past
+ * that indirection use `collectPropRefsTransitive` below, which wraps this
+ * function rather than duplicating its walk.
  */
 function collectPropRefs(
   expr: string | undefined,
@@ -304,6 +425,46 @@ function collectPropRefs(
   visit(node)
 }
 
+/**
+ * `collectPropRefs`, widened to look THROUGH component-scope `const`
+ * locals (#2685 review): a signal/memo initializer often reads a prop one
+ * hop removed — `const mid = props.label; createSignal(mid ?? 'Default')`
+ * — rather than `propsObjectName.X` directly. Runs the existing
+ * direct-access walk over `expr` first (unchanged behavior for the common
+ * case), then finds every VALUE-POSITION identifier `expr` references
+ * (via the analyzer's `extractFreeIdentifiersFromNode` — never a bespoke
+ * identifier scan, so a property-access tail like `foo.mid` or an
+ * object-literal key like `{ mid: 1 }` is correctly NOT mistaken for a
+ * read of a local named `mid`) and, for each one that names a local
+ * const, recurses into THAT const's own value expression the same way.
+ *
+ * `visited` guards re-entering the same const twice — both for the
+ * (source-impossible, since JS TDZ forbids a const referencing itself)
+ * pathological-cycle case, and for the ordinary diamond case (two
+ * branches of `expr` both reading the same local) so it isn't walked
+ * twice. Fresh per top-level call via the default parameter, so unrelated
+ * calls for different signals/memos don't share state.
+ */
+function collectPropRefsTransitive(
+  expr: string | undefined,
+  propsObjectName: string,
+  localConsts: ReadonlyMap<string, string>,
+  out: Set<string>,
+  visited: Set<string> = new Set(),
+): void {
+  if (!expr || !expr.trim()) return
+  collectPropRefs(expr, propsObjectName, out)
+  const node = parseExpression(expr)
+  if (!node) return
+  for (const id of extractFreeIdentifiersFromNode(node)) {
+    if (visited.has(id)) continue
+    const constValue = localConsts.get(id)
+    if (constValue === undefined) continue
+    visited.add(id)
+    collectPropRefsTransitive(constValue, propsObjectName, localConsts, out, visited)
+  }
+}
+
 function resultToJsonable(v: EvalResult): unknown {
   if (v === UNRESOLVED) return null
   if (v === undefined) return null
@@ -366,12 +527,16 @@ function evalStatementsForReturn(
 
 function parseExpression(expr: string): ts.Expression | null {
   // Wrap in parens so a leading `{}` parses as an object literal rather
-  // than an empty block statement.
+  // than an empty block statement. Parent nodes ARE set (unlike a bare
+  // parse) so `collectPropRefsTransitive` can call the analyzer's
+  // `extractFreeIdentifiersFromNode` — which needs `.parent` to tell a
+  // value-position identifier from a property-access tail / object-literal
+  // key / parameter name — on the result.
   const sf = ts.createSourceFile(
     '__ssr_default__.ts',
     `(${expr})`,
     ts.ScriptTarget.Latest,
-    false,
+    true,
     ts.ScriptKind.TS,
   )
   const stmt = sf.statements[0]

package/src/ssr-seed-plan.ts

@@ -35,6 +35,7 @@ import { envSignalReaderFor, type EnvSignalReader } from './adapters/env-signal.
 import {
   extractArrowBodyExpression,
   freeIdentifiers,
+  inlineBinding,
   isSupported,
   parseExpression,
   type ParsedExpr,
@@ -97,6 +98,72 @@ function classify(
   return { kind: 'derived', name, origin, expr, parsed, frees: [...frees] }
 }
 
+/**
+ * Component-scope (non-module) `const` locals, by name, parsed to their
+ * `ParsedExpr` value — the substitution table `resolveThroughLocalConsts`
+ * inlines through. Module-scope consts are excluded: they're already part
+ * of `baseScope` (every adapter compile-time-inlines them to their literal
+ * value, so a reference to one is never a template-variable read — see the
+ * module doc), and a `let` has no stable value to substitute.
+ */
+function localConstExprsByName(metadata: IRMetadata): ReadonlyMap<string, ParsedExpr> {
+  const out = new Map<string, ParsedExpr>()
+  for (const c of metadata.localConstants ?? []) {
+    if (c.isModule || c.declarationKind !== 'const' || c.value === undefined) continue
+    out.set(c.name, c.parsed ?? parseExpression(c.value.trim()))
+  }
+  return out
+}
+
+/**
+ * Resolve a signal/memo's parsed expression through any component-scope
+ * `const` locals it references, so a hop of pure indirection between a
+ * prop read and its derived signal/memo — `const mid = props.label;
+ * createSignal(mid ?? 'Default')` — classifies from the SAME scope its
+ * fully-inlined form (`props.label ?? 'Default'`) would (#2685 review, the
+ * jsx-side twin of `ssr-defaults.ts`'s own `collectPropRefs` closure).
+ *
+ * Structural substitution only (never string splicing, per CLAUDE.md):
+ * reuses `inlineBinding`, the exact "let-inline" step `foldBlockToExpr`
+ * already performs for a block-bodied memo's own internal `const`s. A
+ * chained const (`const a = props.x; const b = a; createSignal(b ?? 1)`)
+ * closes the same way — each pass substitutes whatever local consts are
+ * still free in the current form, so `b` resolves to `a` first and `a`
+ * resolves to `props.x` on the next pass. Bounded to `localConsts.size + 1`
+ * iterations (the longest possible chain) purely as a cycle guard; a real
+ * cycle is impossible in valid source (JS TDZ forbids a const referencing
+ * itself, directly or transitively).
+ *
+ * `inlineBinding` returns `null` only on a capture hazard (the const's own
+ * free variable would be shadowed by a nested callback parameter of the
+ * same name inside the current form) — that occurrence is left un-inlined,
+ * so its name simply stays free and later fails `classify`'s availability
+ * check like any other out-of-scope reference (fails safe to `opaque`,
+ * never a wrong substitution).
+ */
+function resolveThroughLocalConsts(
+  parsed: ParsedExpr,
+  localConsts: ReadonlyMap<string, ParsedExpr>,
+): ParsedExpr {
+  let current = parsed
+  const maxIter = localConsts.size + 1
+  for (let i = 0; i < maxIter; i++) {
+    const frees = freeIdentifiers(current)
+    if (frees === null) break
+    let changed = false
+    for (const name of frees) {
+      const value = localConsts.get(name)
+      if (!value) continue
+      const inlined = inlineBinding(current, name, value)
+      if (inlined === null) continue
+      current = inlined
+      changed = true
+    }
+    if (!changed) break
+  }
+  return current
+}
+
 /**
  * Compute the component's SSR seed plan from its metadata. See the module
  * doc for the contract. Memo steps are gated to EXPRESSION-BODIED memos
@@ -111,6 +178,7 @@ export function computeSsrSeedPlan(metadata: IRMetadata): SsrSeedPlan {
   }
 
   const available = new Set<string>(baseScope)
+  const localConsts = localConstExprsByName(metadata)
   const steps: SsrSeedStep[] = []
 
   for (const signal of metadata.signals) {
@@ -126,7 +194,13 @@ export function computeSsrSeedPlan(metadata: IRMetadata): SsrSeedPlan {
     steps.push(
       expr === ''
         ? { kind: 'opaque', name: signal.getter, origin: 'signal' }
-        : classify(signal.getter, 'signal', expr, parseExpression(expr), available),
+        : classify(
+            signal.getter,
+            'signal',
+            expr,
+            resolveThroughLocalConsts(parseExpression(expr), localConsts),
+            available,
+          ),
     )
     available.add(signal.getter)
   }
@@ -137,7 +211,13 @@ export function computeSsrSeedPlan(metadata: IRMetadata): SsrSeedPlan {
     steps.push(
       expr === ''
         ? { kind: 'opaque', name: memo.name, origin: 'memo' }
-        : classify(memo.name, 'memo', expr, memo.parsed ?? parseExpression(expr), available),
+        : classify(
+            memo.name,
+            'memo',
+            expr,
+            resolveThroughLocalConsts(memo.parsed ?? parseExpression(expr), localConsts),
+            available,
+          ),
     )
     available.add(memo.name)
   }

package/dist/signal-init-eval.d.ts

@@ -1,82 +0,0 @@
-/**
- * TEST-HARNESS ONLY. Evaluate a signal initializer / prop-default source
- * expression against a mock `props` object by EXECUTING it (`new
- * Function`, with `undefined` shadowing the globals listed below), the
- * same way the Hono/CSR conformance reference produces its value — by
- * actually running the component. Never call this from a build path (`bf
- * build`, `compileJSX`, any adapter's `generate`); it exists only so each
- * adapter's `test-render.ts` conformance harness can seed a signal/
- * prop-default for a non-JS-runtime SSR render (PHP/Ruby/Python/Perl/Go)
- * that matches what Hono would compute. (#2209)
- *
- * NOT a security sandbox — the global shadowing below is a determinism
- * tripwire (catches the common accidental-nondeterminism case, e.g.
- * `Date.now()`), not containment: a sufficiently creative expression can
- * still reach the real global scope (`new Function` bodies execute
- * unlexically-scoped, so e.g. `[].constructor.constructor('return
- * Date')()` recovers `Date` even though the bare name is shadowed, and
- * `eval` can't be shadowed at all — JS forbids declaring or binding a
- * parameter literally named `eval` in strict-mode code). Do not widen this
- * module's use to anything but first-party fixture source. The actual
- * trust boundary is that the evaluated text is first-party fixture
- * source, already compiled by this same process — the conformance harness
- * already executes fixture-derived code far more invasively (spawning
- * `ruby`/`php`/`perl`/`go run` on generated programs). This module is
- * never reachable from anything a real end user's untrusted input could
- * influence.
- *
- * Why real execution instead of a hand-rolled evaluator: the initializer
- * source is an arbitrary JS-subset expression over `props` (e.g. `(props.x
- * ?? []).map(t => ({ ...t, editing: false }))`, #2209's actual repro) —
- * every previous approach here was a regex/pattern-match over a small
- * catalogue of recognized shapes (`props.x`, `props.x ?? default`, a bare
- * literal), and #2209 is literally "the catalogue missed a shape" (the
- * THIRD such miss on this codebase, per the superseded
- * `evaluate-signal-init.test.ts`'s own #1672 pins). A hand-written
- * evaluator over `ParsedExpr` would face the same drift, and can't
- * represent object spread (`{ ...t, editing: false }`) without extending
- * `ParsedExpr` — a production-compiler change that ripples into every
- * adapter's exhaustive switch, disproportionate for a test-only need.
- * `new Function` delegates parsing to the JS engine itself — CLAUDE.md's
- * regex-parsing ban exists precisely to avoid the false-match/missed-shape
- * failure mode this replaces.
- *
- * Shadowed as `undefined` (best-effort determinism, not containment — see
- * above): `globalThis`, `window`, `document`, `Date`, `Math`, `crypto`,
- * `performance`, `fetch`, `setTimeout`, `setInterval`, `require`,
- * `process`, `Function`. (`eval` is deliberately absent from this list —
- * it cannot be shadowed as a parameter name in strict-mode code; see
- * above.)
- *
- * `props` bare-identifier destructured params (`createSignal(count)` where
- * `count` is a destructured prop, not a `props.x` member) are NOT bound —
- * the evaluator only exposes `props` — so such an initializer throws
- * `ReferenceError` and falls back to "unset", matching every prior
- * evaluator's behavior for that shape. Extending the environment with
- * `ir.metadata.propsParams` bindings is a natural follow-up if a fixture
- * ever needs it.
- */
-export type SignalInitEvalResult = {
-    ok: true;
-    value: unknown;
-} | {
-    ok: false;
-};
-/**
- * Evaluate `expr` (a JS-subset source expression) against `props`. Returns
- * `{ ok: false }` when the expression fails to parse, throws at evaluation
- * time (e.g. a `ReferenceError` for an unbound identifier), or evaluates to
- * something the downstream serializers can't marshal (see
- * {@link isTransportable}).
- */
-export declare function tryEvaluateSignalInit(expr: string, props?: Record<string, unknown>): SignalInitEvalResult;
-/**
- * Drop-in replacement for the harnesses' former per-adapter regex
- * evaluator: `null` means "could not evaluate, or evaluated to
- * `undefined` — leave the signal/default unseeded", matching every prior
- * evaluator's convention (an explicit JS `null` initializer also maps to
- * `null` — the same "skip" outcome, since none of these harnesses
- * distinguish "explicitly null" from "unset" downstream).
- */
-export declare function evaluateSignalInit(expr: string, props?: Record<string, unknown>): unknown;
-//# sourceMappingURL=signal-init-eval.d.ts.map

package/dist/signal-init-eval.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"signal-init-eval.d.ts","sourceRoot":"","sources":["../src/signal-init-eval.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAkBH,MAAM,MAAM,oBAAoB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAA;CAAE,CAAA;AAqC/E;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,oBAAoB,CA6BtB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAGzF"}

package/src/__tests__/signal-init-eval.test.ts

@@ -1,138 +0,0 @@
-import { describe, test, expect } from 'bun:test'
-import { evaluateSignalInit, tryEvaluateSignalInit } from '../signal-init-eval'
-
-// #2209: replaces 7 near-duplicate regex-based `evaluateSignalInit`
-// evaluators (one per template-string adapter's test-render.ts harness)
-// with a single sandboxed real-JS evaluator. Absorbs and supersedes
-// `packages/adapter-mojolicious/src/__tests__/evaluate-signal-init.test.ts`
-// (#1672's pins) plus the actual #2209 repro shape.
-describe('evaluateSignalInit (#2209)', () => {
-  test('the #2209 repro: (props.x ?? []).map(t => ({ ...t, editing: false }))', () => {
-    const expr = `(props.initialTodos ?? []).map(t => ({ ...t, editing: false }))`
-    expect(evaluateSignalInit(expr, { initialTodos: [{ id: 1, done: false }] })).toEqual([
-      { id: 1, done: false, editing: false },
-    ])
-    expect(evaluateSignalInit(expr, undefined)).toEqual([])
-    expect(evaluateSignalInit(expr, {})).toEqual([])
-  })
-
-  test('an object-spread override applies after the spread (matches JS semantics)', () => {
-    const expr = `(props.items ?? []).map(t => ({ ...t, done: true }))`
-    expect(evaluateSignalInit(expr, { items: [{ id: 1, done: false }] })).toEqual([
-      { id: 1, done: true },
-    ])
-  })
-
-  // #1672 pins, absorbed from the deleted mojolicious-local test file.
-  test('parses an inline object-array initial value', () => {
-    expect(evaluateSignalInit(`[{ id: 'a' }, { id: 'b' }, { id: 'c' }]`)).toEqual([
-      { id: 'a' },
-      { id: 'b' },
-      { id: 'c' },
-    ])
-  })
-
-  test('parses scalar and mixed arrays, including nested objects', () => {
-    expect(evaluateSignalInit(`['x', 'y']`)).toEqual(['x', 'y'])
-    expect(evaluateSignalInit(`[1, 2, 3]`)).toEqual([1, 2, 3])
-    expect(evaluateSignalInit(`[{ id: 'a', n: 1, ok: true }]`)).toEqual([
-      { id: 'a', n: 1, ok: true },
-    ])
-  })
-
-  test('still parses scalars, empty array, and props passthrough', () => {
-    expect(evaluateSignalInit(`'b'`)).toBe('b')
-    expect(evaluateSignalInit(`5`)).toBe(5)
-    expect(evaluateSignalInit(`[]`)).toEqual([])
-    expect(evaluateSignalInit(`props.value`, { value: 42 })).toBe(42)
-  })
-
-  test('bails to null for arrays with non-literal, unbound elements', () => {
-    expect(evaluateSignalInit(`[foo(), bar]`)).toBeNull()
-  })
-
-  // Additional shapes the old regex evaluators supported.
-  test('props.x ?? default with x present, absent, or explicitly null', () => {
-    expect(evaluateSignalInit(`props.x ?? 7`, { x: 3 })).toBe(3)
-    expect(evaluateSignalInit(`props.x ?? 7`, {})).toBe(7)
-    expect(evaluateSignalInit(`props.x ?? 7`, undefined)).toBe(7)
-    // Fix over the old regex evaluators: JS `??` also falls through on an
-    // explicit `null`/`undefined` prop value — the old regex only checked
-    // `propName in props` and returned the raw (null) value, which was
-    // actually a bug relative to real JS `??` semantics.
-    expect(evaluateSignalInit(`props.x ?? 7`, { x: null })).toBe(7)
-  })
-
-  test('negative and decimal number literals', () => {
-    expect(evaluateSignalInit(`-7.6`)).toBe(-7.6)
-    expect(evaluateSignalInit(`42`)).toBe(42)
-  })
-
-  test('booleans', () => {
-    expect(evaluateSignalInit(`true`)).toBe(true)
-    expect(evaluateSignalInit(`false`)).toBe(false)
-  })
-
-  test('an explicit null initializer maps to null (the "skip" outcome)', () => {
-    expect(evaluateSignalInit(`null`)).toBeNull()
-  })
-
-  // New coverage for #2209's sandboxing contract.
-  test('blocked globals fail deterministically and fall back to null', () => {
-    expect(evaluateSignalInit(`Date.now()`)).toBeNull()
-    expect(evaluateSignalInit(`Math.random()`)).toBeNull()
-    expect(evaluateSignalInit(`typeof window`)).not.toBe('object')
-  })
-
-  test('a TS-only remnant that fails to parse as an expression falls back to null', () => {
-    expect(evaluateSignalInit(`foo as Bar`)).toBeNull()
-  })
-
-  test('a non-transportable value (class instance) falls back to null', () => {
-    expect(evaluateSignalInit(`new Set([1, 2])`)).toBeNull()
-  })
-
-  test('a bare destructured-prop identifier (not props.x) is unbound and falls back to null', () => {
-    expect(evaluateSignalInit(`count`, { count: 5 })).toBeNull()
-  })
-
-  test('tryEvaluateSignalInit distinguishes an explicit undefined from a real ok:false', () => {
-    expect(tryEvaluateSignalInit(`undefined`)).toEqual({ ok: true, value: undefined })
-    expect(tryEvaluateSignalInit(`foo()`)).toEqual({ ok: false })
-    // evaluateSignalInit's wrapper collapses both to null:
-    expect(evaluateSignalInit(`undefined`)).toBeNull()
-    expect(evaluateSignalInit(`foo()`)).toBeNull()
-  })
-
-  // Copilot review (#2229): `Function` is now shadowed too — closes the
-  // most direct bypass of the blocked-globals list.
-  test('the Function constructor is shadowed', () => {
-    expect(evaluateSignalInit(`Function('return 1')()`)).toBeNull()
-  })
-
-  // Copilot review (#2229): `isTransportable` must reject a sparse array
-  // (a hole is not the same as an element that's explicitly `undefined` —
-  // `Array.prototype.every` silently skips holes, which previously let
-  // one through undetected).
-  test('a sparse array (a hole, not an explicit undefined) falls back to null', () => {
-    // biome-ignore lint: intentional sparse-array literal for the hole test
-    expect(evaluateSignalInit(`[1, , 3]`)).toBeNull()
-  })
-
-  // Copilot review (#2229): the same object appearing twice in a
-  // non-cyclic shape (shared by reference, not by cycle) is transportable
-  // — JSON-equivalent behavior would just duplicate it — and must NOT be
-  // rejected by an overly-global "seen" set.
-  test('a shared (non-cyclic) reference is transportable', () => {
-    expect(evaluateSignalInit(`(() => { const shared = { id: 1 }; return [shared, shared] })()`)).toEqual([
-      { id: 1 },
-      { id: 1 },
-    ])
-  })
-
-  test('a genuine cycle still falls back to null', () => {
-    expect(
-      evaluateSignalInit(`(() => { const o = { id: 1 }; o.self = o; return o })()`),
-    ).toBeNull()
-  })
-})