@barefootjs/jsx 0.31.10 → 0.33.0

package/src/ssr-seed-plan.ts

@@ -36,7 +36,7 @@ import {
   extractArrowBodyExpression,
   freeIdentifiers,
   inlineBinding,
-  isSupported,
+  isSupportedValue,
   parseExpression,
   type ParsedExpr,
 } from './expression-parser.ts'
@@ -81,6 +81,11 @@ export interface SsrSeedPlan {
  * opaque). The scope check runs over the parsed SOURCE tree, so a shadowed
  * name (`items.filter((p) => p.ok) && p`, where the trailing `p` is a
  * different, unbound reference from the callback's own param) is rejected.
+ *
+ * Uses `isSupportedValue`, not `isSupported`: a signal/memo initializer is an
+ * ASSIGNMENT, never a render, so it's checked at VALUE position — this is
+ * what admits e.g. `createSignal([{ a: 'p' }].map(t => t.a).join(','))`
+ * (an object-literal array-method receiver) as `derived` instead of opaque.
  */
 function classify(
   name: string,
@@ -89,7 +94,7 @@ function classify(
   parsed: ParsedExpr,
   available: ReadonlySet<string>,
 ): SsrSeedStep {
-  if (!isSupported(parsed).supported) return { kind: 'opaque', name, origin }
+  if (!isSupportedValue(parsed).supported) return { kind: 'opaque', name, origin }
   const frees = freeIdentifiers(parsed)
   if (frees === null) return { kind: 'opaque', name, origin }
   for (const free of frees) {
@@ -198,7 +203,19 @@ export function computeSsrSeedPlan(metadata: IRMetadata): SsrSeedPlan {
             signal.getter,
             'signal',
             expr,
-            resolveThroughLocalConsts(parseExpression(expr), localConsts),
+            // Prefer the analyzer's already-parenthesised parse (`analyzer.ts`'s
+            // `parseExpression(\`(${signal.initialValue})\`)`, Roadmap A) over
+            // re-parsing the bare `expr` string here — re-parsing WITHOUT the
+            // wrap misreads a bare object-literal initializer
+            // (`createSignal({ ...base, done: true })`) as a block statement
+            // (`parseExpression`'s documented block-vs-expression-statement
+            // rule), silently opaquing an otherwise-derivable signal (#2696
+            // Step 2 follow-up: this only became observable once `object-
+            // literal` could classify `derived` at all). Falling back to a
+            // parenthesised re-parse (not the bare string) keeps a signal
+            // whose shape the analyzer's pass left unparsed (`signal.parsed`
+            // undefined) equally safe.
+            resolveThroughLocalConsts(signal.parsed ?? parseExpression(`(${expr})`), localConsts),
             available,
           ),
     )

package/src/static-literal.ts

@@ -60,9 +60,23 @@ export function evaluateStaticLiteral(
       // Shorthand (`{ a }`) and explicit (`{ a: value }`) properties both
       // carry their resolved tree in `value` (shorthand's is an
       // `identifier`) — recursing here handles both uniformly: a shorthand
-      // property only resolves when `bindings` supplies it.
+      // property only resolves when `bindings` supplies it. A spread
+      // (`{ ...base, a: 1 }`, #2696 Step 2) resolves its source and merges
+      // in source order — the same shallow-merge, later-wins, null/undefined-
+      // is-a-no-op semantics as the runtime evaluator (`toEvalNode`'s
+      // `object-literal` case) and JS itself; a spread source that resolves
+      // to anything other than a plain object/null/undefined isn't
+      // statically mergeable here, so the whole literal declines.
       const out: Record<string, unknown> = {}
       for (const prop of expr.properties) {
+        if (prop.kind === 'spread') {
+          const resolved = evaluateStaticLiteral(prop.expr, bindings)
+          if (!resolved) return null
+          if (resolved.value === null || resolved.value === undefined) continue
+          if (typeof resolved.value !== 'object' || Array.isArray(resolved.value)) return null
+          Object.assign(out, resolved.value)
+          continue
+        }
         const resolved = evaluateStaticLiteral(prop.value, bindings)
         if (!resolved) return null
         out[prop.key] = resolved.value

package/src/to-locale-date-lowering.ts

@@ -504,6 +504,10 @@ export function matchToLocaleDateStringCall(
   let tz: string | null = null
   const probeOptions: Record<string, string> = {}
   for (const prop of options.properties) {
+    // A spread (`{ ...opts, timeZone: 'UTC' }`, #2696 Step 2) isn't a
+    // literal-keyed entry this probe can read without evaluating the spread
+    // source — decline rather than silently skipping its keys.
+    if (prop.kind === 'spread') return null
     if (prop.value.kind !== 'literal' || prop.value.literalType !== 'string') return null
     const value = String(prop.value.value)
     if (prop.key === 'timeZone') {

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()
-  })
-})

package/src/signal-init-eval.ts

@@ -1,165 +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.
- */
-
-const BLOCKED_GLOBALS = [
-  'globalThis',
-  'window',
-  'document',
-  'Date',
-  'Math',
-  'crypto',
-  'performance',
-  'fetch',
-  'setTimeout',
-  'setInterval',
-  'require',
-  'process',
-  'Function',
-] as const
-
-export type SignalInitEvalResult = { ok: true; value: unknown } | { ok: false }
-
-/**
- * A value the harness's downstream language serializers (JSON/Python/PHP/
- * Perl/Ruby literal builders) can actually marshal: `null`, a boolean, a
- * number (including non-finite — several serializers already special-case
- * NaN/Infinity), a string, a dense array with no holes and no `undefined`
- * elements, or a plain object (`Object.prototype` or null prototype only —
- * rejects class instances, functions, Maps/Sets, etc). Rejects genuine
- * cycles; a shared (non-cyclic) reference appearing more than once — e.g.
- * the same object at two array indices — is fine (JSON-equivalent
- * behavior just duplicates it), so `ancestors` tracks only the current
- * recursion path, not every value ever visited.
- */
-function isTransportable(value: unknown, ancestors: Set<unknown> = new Set()): boolean {
-  if (value === null) return true
-  const t = typeof value
-  if (t === 'boolean' || t === 'number' || t === 'string') return true
-  if (t !== 'object') return false
-  if (ancestors.has(value)) return false // a real cycle (value is its own ancestor)
-  ancestors.add(value)
-  try {
-    if (Array.isArray(value)) {
-      // `Array.prototype.every` silently skips holes (`[1, , 3]`), so a
-      // sparse array would otherwise pass — compare against the own
-      // enumerable key count (holes aren't own keys) to catch that.
-      if (Object.keys(value).length !== value.length) return false
-      return value.every(el => el !== undefined && isTransportable(el, ancestors))
-    }
-    const proto = Object.getPrototypeOf(value)
-    if (proto !== Object.prototype && proto !== null) return false
-    return Object.values(value as Record<string, unknown>).every(v => isTransportable(v, ancestors))
-  } finally {
-    ancestors.delete(value)
-  }
-}
-
-/**
- * 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 function tryEvaluateSignalInit(
-  expr: string,
-  props?: Record<string, unknown>,
-): SignalInitEvalResult {
-  const src = expr.trim()
-  if (src === '') return { ok: false }
-  let fn: (props: Record<string, unknown>, ...blocked: undefined[]) => unknown
-  try {
-    // `props` plus the blocked-globals shadows are the only bindings
-    // passed in — best-effort determinism, not containment; see the file
-    // docstring for the trust-boundary rationale (test-harness-only,
-    // never a build path).
-    fn = new Function(
-      'props',
-      ...BLOCKED_GLOBALS,
-      `'use strict'; return (\n${src}\n);`,
-    ) as typeof fn
-  } catch {
-    return { ok: false }
-  }
-  try {
-    const value = fn(props ?? {})
-    // `undefined` at the TOP level is a genuine, distinguishable result
-    // (e.g. an explicit `undefined` initializer, or `props.x` with no `x`
-    // and no `??` fallback) — not a marshal failure. `evaluateSignalInit`'s
-    // wrapper still collapses it to the "skip" outcome; callers that need
-    // the distinction use this function directly.
-    if (value === undefined) return { ok: true, value: undefined }
-    return isTransportable(value) ? { ok: true, value } : { ok: false }
-  } catch {
-    return { ok: false }
-  }
-}
-
-/**
- * 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 function evaluateSignalInit(expr: string, props?: Record<string, unknown>): unknown {
-  const result = tryEvaluateSignalInit(expr, props)
-  return result.ok && result.value !== undefined ? result.value : null
-}