@barefootjs/jsx 0.18.5 → 0.19.0

package/src/__tests__/static-literal.test.ts

@@ -0,0 +1,126 @@
+import { describe, test, expect } from 'bun:test'
+import { parseExpression } from '../expression-parser'
+import { evaluateStaticLiteral, isFullyStaticLiteral, resolveStaticLoopSource } from '../static-literal'
+import type { ConstantInfo } from '../types'
+
+// #2208: a function-scope local const whose initializer is fully known at
+// compile time (no prop/signal/function-call dependency) should bind as a
+// loop source the same way a module-scope const already does.
+describe('evaluateStaticLiteral (#2208)', () => {
+  test('scalars', () => {
+    expect(evaluateStaticLiteral(parseExpression("'Alpha'"))).toEqual({ value: 'Alpha' })
+    expect(evaluateStaticLiteral(parseExpression('42'))).toEqual({ value: 42 })
+    expect(evaluateStaticLiteral(parseExpression('true'))).toEqual({ value: true })
+    expect(evaluateStaticLiteral(parseExpression('null'))).toEqual({ value: null })
+  })
+
+  test('a no-substitution template literal', () => {
+    expect(evaluateStaticLiteral(parseExpression('`hello`'))).toEqual({ value: 'hello' })
+  })
+
+  test('a template literal whose substitutions are all static', () => {
+    expect(evaluateStaticLiteral(parseExpression("`a${1}b${'c'}`"))).toEqual({ value: 'a1bc' })
+  })
+
+  test('a template literal with a non-static substitution is not static', () => {
+    expect(evaluateStaticLiteral(parseExpression('`a${x}`'))).toBeNull()
+  })
+
+  test('nested array and object literals', () => {
+    expect(evaluateStaticLiteral(parseExpression("[{ label: 'Alpha' }, { label: 'Beta' }]"))).toEqual({
+      value: [{ label: 'Alpha' }, { label: 'Beta' }],
+    })
+    expect(evaluateStaticLiteral(parseExpression("({ a: [1, 2, { b: 'c' }] })"))).toEqual({
+      value: { a: [1, 2, { b: 'c' }] },
+    })
+  })
+
+  test('unary minus/plus/not over a static operand', () => {
+    expect(evaluateStaticLiteral(parseExpression('-5'))).toEqual({ value: -5 })
+    expect(evaluateStaticLiteral(parseExpression('+5'))).toEqual({ value: 5 })
+    expect(evaluateStaticLiteral(parseExpression('!true'))).toEqual({ value: false })
+  })
+
+  test('an empty array literal is static', () => {
+    expect(evaluateStaticLiteral(parseExpression('[]'))).toEqual({ value: [] })
+  })
+
+  test('object shorthand property is not static without bindings', () => {
+    // `{ label }` parses `label`'s value as an `identifier` — only
+    // resolvable when a caller supplies bindings for it.
+    expect(evaluateStaticLiteral(parseExpression('({ label })'))).toBeNull()
+  })
+
+  test('a call expression is not static', () => {
+    expect(evaluateStaticLiteral(parseExpression("Object.entries({ a: 1 })"))).toBeNull()
+  })
+
+  test('a props member access is not static', () => {
+    expect(evaluateStaticLiteral(parseExpression('props.tags'))).toBeNull()
+  })
+
+  test('a bare identifier resolves only through bindings', () => {
+    const expr = parseExpression('item')
+    expect(evaluateStaticLiteral(expr)).toBeNull()
+    expect(evaluateStaticLiteral(expr, new Map([['item', 'Alpha']]))).toEqual({ value: 'Alpha' })
+  })
+
+  test('a member access resolves against a bound object', () => {
+    const expr = parseExpression('item.label')
+    expect(evaluateStaticLiteral(expr, new Map([['item', { label: 'Alpha' }]]))).toEqual({ value: 'Alpha' })
+  })
+
+  test('isFullyStaticLiteral mirrors evaluateStaticLiteral', () => {
+    expect(isFullyStaticLiteral(parseExpression("[{ label: 'Alpha' }]"))).toBe(true)
+    expect(isFullyStaticLiteral(parseExpression('props.tags'))).toBe(false)
+  })
+})
+
+describe('resolveStaticLoopSource (#2208)', () => {
+  function constant(overrides: Partial<ConstantInfo>): ConstantInfo {
+    return {
+      name: 'items',
+      declarationKind: 'const',
+      type: null,
+      loc: { line: 0, column: 0 },
+      ...overrides,
+    } as ConstantInfo
+  }
+
+  test('an inline array-literal loop source resolves directly (no named local needed)', () => {
+    const result = resolveStaticLoopSource(parseExpression("[{ label: 'Alpha' }, { label: 'Beta' }]"), [])
+    expect(result).toEqual([{ label: 'Alpha' }, { label: 'Beta' }])
+  })
+
+  test('a bare identifier resolves against a FUNCTION-scope local const with a static initializer', () => {
+    const locals = [constant({ name: 'items', parsed: parseExpression("[{ label: 'Alpha' }]") })]
+    expect(resolveStaticLoopSource(parseExpression('items'), locals)).toEqual([{ label: 'Alpha' }])
+  })
+
+  test('a MODULE-scope const is excluded (handled by the existing seeding path instead)', () => {
+    const locals = [constant({ name: 'items', parsed: parseExpression("[{ label: 'Alpha' }]"), isModule: true })]
+    expect(resolveStaticLoopSource(parseExpression('items'), locals)).toBeNull()
+  })
+
+  test('a runtime-computed local const (#2069) still refuses', () => {
+    const locals = [constant({ name: 'entries', parsed: parseExpression('Object.entries(props.tags)') })]
+    expect(resolveStaticLoopSource(parseExpression('entries'), locals)).toBeNull()
+  })
+
+  test('an identifier not naming any local const refuses', () => {
+    expect(resolveStaticLoopSource(parseExpression('items'), [])).toBeNull()
+  })
+
+  test('a shadowed name is excluded via isNameShadowed', () => {
+    const locals = [constant({ name: 'items', parsed: parseExpression("[{ label: 'Alpha' }]") })]
+    const result = resolveStaticLoopSource(parseExpression('items'), locals, {
+      isNameShadowed: name => name === 'items',
+    })
+    expect(result).toBeNull()
+  })
+
+  test('a static value that is not an array refuses', () => {
+    const locals = [constant({ name: 'obj', parsed: parseExpression("{ a: 1 }") })]
+    expect(resolveStaticLoopSource(parseExpression('obj'), locals)).toBeNull()
+  })
+})

package/src/__tests__/string-concat-identifier.test.ts

@@ -0,0 +1,55 @@
+import { describe, test, expect } from 'bun:test'
+import { isStringTypedOperand, isStringConcatBinary } from '../adapters/parsed-expr-emitter'
+import { parseExpression } from '../expression-parser'
+
+// #2212: `isStringTypedOperand` gained a bare-`identifier` arm — previously
+// `a + b` where BOTH operands are plain identifiers (destructured props,
+// same-file consts) fell through every existing arm (literal, template
+// literal, zero-arg getter, `props.x` member) and was treated as numeric
+// `+`, even when both operands are string-typed. Twig/Blade/Mojolicious/
+// Xslate route a detected string-concat through their own concat operator
+// instead of native `+` (numeric-only on all four); this pins the shared
+// detection function itself, independent of any one adapter's emitter.
+describe('isStringTypedOperand identifier arm (#2212)', () => {
+  const isStr = (n: string) => n === 'first' || n === 'last'
+
+  test('a bare identifier known to be string-typed is detected', () => {
+    const expr = parseExpression('first')
+    expect(isStringTypedOperand(expr, isStr)).toBe(true)
+  })
+
+  test('a bare identifier NOT in the known-string set is not detected', () => {
+    const expr = parseExpression('count')
+    expect(isStringTypedOperand(expr, isStr)).toBe(false)
+  })
+
+  test('isStringConcatBinary(+) is true when only ONE identifier operand is string-typed', () => {
+    const parsed = parseExpression('first + count')
+    if (parsed.kind !== 'binary') throw new Error('expected binary')
+    expect(isStringConcatBinary(parsed.op, parsed.left, parsed.right, isStr)).toBe(true)
+  })
+
+  test('isStringConcatBinary(+) is false when NEITHER identifier operand is known string-typed', () => {
+    const parsed = parseExpression('count + total')
+    if (parsed.kind !== 'binary') throw new Error('expected binary')
+    expect(isStringConcatBinary(parsed.op, parsed.left, parsed.right, isStr)).toBe(false)
+  })
+
+  test('two bare-identifier string operands: first + last', () => {
+    const parsed = parseExpression('first + last')
+    if (parsed.kind !== 'binary') throw new Error('expected binary')
+    expect(isStringConcatBinary(parsed.op, parsed.left, parsed.right, isStr)).toBe(true)
+  })
+
+  test('a nested + chain of bare identifiers still resolves via the existing binary-recursion arm', () => {
+    const parsed = parseExpression('first + count + last')
+    if (parsed.kind !== 'binary') throw new Error('expected binary')
+    expect(isStringConcatBinary(parsed.op, parsed.left, parsed.right, isStr)).toBe(true)
+  })
+
+  test('a non-+ binary op is never treated as string concat regardless of operand names', () => {
+    const parsed = parseExpression('first - last')
+    if (parsed.kind !== 'binary') throw new Error('expected binary')
+    expect(isStringConcatBinary(parsed.op, parsed.left, parsed.right, isStr)).toBe(false)
+  })
+})

package/src/adapters/dangerous-inner-html.ts

@@ -0,0 +1,186 @@
+/**
+ * Shared `dangerouslySetInnerHTML={{ __html: expr }}` recognition + policy
+ * (#2207). Single place every template adapter calls from `renderElement`,
+ * so the injection-safety-relevant policy — "only a compile-time string
+ * literal is lowered; anything else refuses loudly" — lives in exactly one
+ * reviewable spot instead of being re-derived independently in 8 adapters.
+ *
+ * Scope, deliberately narrow for v1 (see #2207 / #2215 for the follow-up):
+ * a static literal is spliced directly into the adapter's OWN template
+ * source as trusted text (same trust domain as hand-writing the HTML into
+ * the template) — never routed through a `|safe`/`|raw`/`{!! !!}`-style
+ * runtime raw-output primitive, which would reopen a template-source
+ * injection surface for no benefit (the value is already fully known at
+ * compile time). A DYNAMIC value (signal, prop, a template literal WITH a
+ * substitution, local const, anything non-literal) is refused with
+ * `BF101` — a no-substitution template literal is NOT dynamic; the parser
+ * normalizes it to the same `{kind:'literal', literalType:'string'}` shape
+ * as a plain string literal, so it's treated identically (see
+ * `staticHtmlLiteral` below). Hono/CSR already support it (the client
+ * drives a `createEffect`-based `el.innerHTML = …`
+ * assignment — see `ir-to-client-js/emit-reactive.ts`), so this is a
+ * template-adapter-only gap, tracked separately (#2215) rather than folded
+ * into this literal-only cut.
+ */
+
+import type { CompilerError, IRAttribute, IRElement, SourceLocation } from '../types.ts'
+import { parseExpression, type ParsedExpr } from '../expression-parser.ts'
+
+const DANGEROUS_INNER_HTML_ATTR = 'dangerouslySetInnerHTML'
+
+export function isDangerousInnerHtmlAttr(attr: IRAttribute): boolean {
+  return attr.name === DANGEROUS_INNER_HTML_ATTR
+}
+
+export type DangerousInnerHtmlResolution =
+  | { kind: 'static'; html: string }
+  | { kind: 'dynamic'; expr: string; loc: SourceLocation }
+
+/**
+ * Resolve `element`'s `dangerouslySetInnerHTML` attribute, if present.
+ * Returns `null` when the attribute is absent (the overwhelmingly common
+ * case — callers should treat `null` as "render this element normally") —
+ * or when it carries `/* @client *\/` (Fable review, #2217): a `clientOnly`
+ * attr is already deferred to hydrate by every adapter's `renderAttributes`
+ * (`if (attr.clientOnly) continue`, unrelated to this module), which is
+ * itself a working escape hatch for a dynamic `__html` — the client's
+ * `createEffect`-driven `el.innerHTML = …` assignment (`emit-reactive.ts`)
+ * runs regardless of what SSR does. Treating `clientOnly` as "render this
+ * element normally" here (rather than refusing with BF101) preserves that
+ * escape hatch instead of regressing it.
+ * A present-but-non-`expression` value (e.g. a bare boolean/spread — not a
+ * shape `{ __html }` can ever legitimately take) is treated as `dynamic`
+ * so it refuses rather than silently doing nothing.
+ */
+export function resolveDangerousInnerHtml(element: IRElement): DangerousInnerHtmlResolution | null {
+  const attr = element.attrs.find(isDangerousInnerHtmlAttr)
+  if (!attr) return null
+  if (attr.clientOnly) return null
+  if (attr.value.kind !== 'expression') {
+    return { kind: 'dynamic', expr: '', loc: attr.loc }
+  }
+  const parsed = attr.value.parsed ?? parseExpression(attr.value.expr.trim())
+  const html = staticHtmlLiteral(parsed)
+  if (html !== null) return { kind: 'static', html }
+  return { kind: 'dynamic', expr: attr.value.expr, loc: attr.loc }
+}
+
+/**
+ * `{ __html: '<b>bold</b>' }` → the literal string, nothing else. Exactly
+ * one property, key `__html` (identifier or string form — `{ __html: … }`
+ * and `{ '__html': … }` are equivalent JS), non-shorthand (`{ __html }`
+ * would read a variable, not a literal), value a compile-time STRING
+ * LITERAL `ParsedExpr` (`{kind:'literal', literalType:'string'}`) — which
+ * a no-substitution template literal (`` `<b>bold</b>` ``) already parses
+ * to, so it's accepted the same as a quoted string. A template literal
+ * WITH a substitution, a local `const`, string concatenation, or any other
+ * non-literal shape all fall through to `null` — no const-folding, no
+ * partial evaluation. Widening this is a single-place change here,
+ * deliberately not attempted in v1 (#2207).
+ */
+function staticHtmlLiteral(parsed: ParsedExpr): string | null {
+  if (parsed.kind !== 'object-literal') return null
+  if (parsed.properties.length !== 1) return null
+  const [prop] = parsed.properties
+  if (prop.shorthand) return null
+  if (prop.key !== '__html') return null
+  if (prop.value.kind !== 'literal' || prop.value.literalType !== 'string') return null
+  return prop.value.value as string
+}
+
+/**
+ * Per-adapter template-metacharacter guard for the STATIC-literal path.
+ * The literal is spliced into the adapter's own template source as plain
+ * text — safe against HTML injection (it's the developer's own compile-time
+ * string, same trust boundary as writing the HTML by hand), but NOT
+ * automatically safe against TEMPLATE-source injection: a literal
+ * containing `{{ … }}` (Go/Jinja/minijinja/Twig), `<% … %>` (ERB/
+ * Mojolicious), `{!! !!}`/`@directive`/`<?php`/`<x-…>` (Blade — the last is
+ * Laravel's component-tag syntax, on by default; see below), or `<: … :>`
+ * (Xslate) would be interpreted as a live template construct instead of
+ * inert text once spliced in. Mojolicious and Xslate also support
+ * whole-line "line code" (a line starting with `%`/`:`, possibly indented —
+ * `\s` covers the same whitespace class Mojo::Template/Xslate strip),
+ * checked with `m`. Refuses (via {@link dangerousInnerHtmlDiagnostic})
+ * rather than escaping — escaping a supposedly-raw-HTML literal would
+ * silently corrupt the developer's own markup, which is worse than a loud
+ * compile-time refusal.
+ *
+ * Blade's `<x-…>`/`</x-…>`: this project's `BladeBackend` constructs a
+ * plain `Illuminate\View\Compilers\BladeCompiler`, whose component-tag
+ * compiler (`$compilesComponentTags = true` by default) resolves and
+ * renders a live Blade component for `<x-foo>` — NOT template-substitution,
+ * full component-class/view resolution (Fable review, #2217). This is the
+ * single sharpest case of "not inert text once spliced" in the whole guard
+ * table, sharper than a bare `{{ }}` interpolation.
+ *
+ * Go's `html/template` context-aware escaper is a DOCUMENTED caveat, not a
+ * guarded case: it parses the spliced literal to pick escaping contexts for
+ * SUBSEQUENT `{{ }}` actions in the same template, so malformed markup (an
+ * unclosed `<script>`/`<style>`) can produce a template `Parse` error or
+ * mis-contexted escaping of later actions — output corruption, never
+ * injection, and no different from hand-writing the same malformed HTML
+ * into the template (this module's stated trust domain). The `{{` guard
+ * below still catches the actual injection vector (a literal containing a
+ * live action).
+ */
+const TEMPLATE_METACHAR_PATTERNS: Readonly<Record<string, RegExp>> = {
+  blade: /\{\{|\{!!|<\?|@\w|<\/?\s*x[-:]/,
+  erb: /<%/,
+  'go-template': /\{\{/,
+  jinja: /\{\{|\{%|\{#/,
+  minijinja: /\{\{|\{%|\{#/,
+  mojolicious: /<%|^\s*%/m,
+  twig: /\{\{|\{%|\{#/,
+  xslate: /<:|^\s*:/m,
+}
+
+/**
+ * `null` when `html` is safe to splice as-is into `adapterId`'s template
+ * source; otherwise a human-readable reason naming the offending adapter's
+ * metacharacter family (or the missing-guard case below), for the refusal
+ * message.
+ *
+ * FAILS CLOSED for an `adapterId` with no entry in
+ * {@link TEMPLATE_METACHAR_PATTERNS} (Fable review, #2217): a 9th template
+ * adapter added later — e.g. by following the repo's own `add-adapter`
+ * playbook, which will tell it to wire the same
+ * `resolveDangerousInnerHtml`/`dangerousInnerHtmlMetacharViolation` calls
+ * every existing adapter does — must not silently get an unguarded splice
+ * just because nobody remembered to extend this table. Refusing loudly is
+ * the safe default; only the 8 adapters actually verified against their
+ * own template compiler's syntax get to skip the refusal.
+ */
+export function dangerousInnerHtmlMetacharViolation(html: string, adapterId: string): string | null {
+  const pattern = TEMPLATE_METACHAR_PATTERNS[adapterId]
+  if (!pattern) {
+    return `no template-metacharacter guard is defined for adapter '${adapterId}' — refusing rather than splicing unguarded`
+  }
+  if (!pattern.test(html)) return null
+  return `the literal HTML contains a sequence ${adapterId}'s own template compiler would interpret (not inert text once spliced into the template)`
+}
+
+/**
+ * Purpose-built `BF101` for a `dangerouslySetInnerHTML` value this adapter
+ * can't lower — either genuinely dynamic (not a literal) or a static
+ * literal that fails the metachar guard above. Named `reason` so both
+ * refusal paths funnel through the same message shape rather than growing
+ * two near-identical adapter-side error strings.
+ */
+export function dangerousInnerHtmlDiagnostic(
+  expr: string,
+  loc: SourceLocation,
+  reason?: string,
+): CompilerError {
+  const detail = reason ? ` — ${reason}.` : ''
+  return {
+    code: 'BF101',
+    severity: 'error',
+    message: `dangerouslySetInnerHTML requires a compile-time string literal __html value on template adapters (e.g. { __html: '...' })${expr ? `: ${expr.trim()}` : ''}${detail}`,
+    loc,
+    suggestion: {
+      message:
+        'Dynamic or signal-derived HTML for dangerouslySetInnerHTML is only supported on Hono/CSR today (tracked separately: https://github.com/piconic-ai/barefootjs/issues/2215). Use an inline string literal, or defer it to the client with /* @client */ (e.g. dangerouslySetInnerHTML={/* @client */ { __html: expr }}) so hydration sets it instead of SSR.',
+    },
+  }
+}

package/src/adapters/loop-bound-names.ts

@@ -0,0 +1,80 @@
+/**
+ * Every name a `.map()`/`.filter()` loop callback binds as its item or
+ * index parameter, anywhere in a component's IR tree (#2212 review
+ * finding). `isStringTypedOperand`'s identifier arm resolves a bare
+ * identifier against `collectStringValueNames`'s flat, scope-BLIND
+ * `Set<string>` — so a loop callback whose param happens to reuse a
+ * string prop's name (`items.map((name) => ... 1 + name ...)`, where the
+ * component also has a string `name` prop) would otherwise be
+ * misdetected as string-typed, silently lowering a NUMERIC `+` to the
+ * adapter's string-concat operator instead of leaving it numeric — wrong
+ * rendered output, not a refusal. Subtracting every loop-bound name from
+ * the string-name set (in each adapter's `collectStringValueNames`) is a
+ * coarse but SAFE mitigation: a name used as a loop param anywhere in the
+ * component never gets string-concat treatment anywhere in the
+ * component, even at a non-shadowed use site outside that loop — which
+ * degrades to the ALREADY-accepted residual (`+` falls back to numeric,
+ * same as before #2212 for an unresolvable operand) rather than ever
+ * producing silently-wrong output.
+ */
+
+import type { ComponentIR, IRNode } from '../types.ts'
+
+export function collectLoopBoundNames(ir: ComponentIR): Set<string> {
+  const names = new Set<string>()
+  const visit = (node: IRNode | null | undefined): void => {
+    if (!node) return
+    switch (node.type) {
+      case 'element':
+      case 'component':
+      case 'fragment':
+      case 'provider':
+        for (const child of node.children) visit(child)
+        break
+      case 'async':
+        visit(node.fallback)
+        for (const child of node.children) visit(child)
+        break
+      case 'loop':
+        names.add(node.param)
+        if (node.index) names.add(node.index)
+        // A destructured callback param (`.map(({ name }) => ...)`) binds
+        // its extracted names via `paramBindings`, not `param` itself
+        // (`param` holds the raw pattern text there) — adapters that lower
+        // the destructure to a `{% set name = __bf_item.name %}`-style
+        // local (#2087) leave `name` reachable as a bare identifier in the
+        // body, so it needs the same exclusion as a plain loop param.
+        for (const binding of node.paramBindings ?? []) names.add(binding.name)
+        // A `.filter(pred).map(cb)` chain's filter predicate is emitted
+        // through the same binary/string-name machinery, using its OWN
+        // param (which may differ from the map callback's `param`) before
+        // any rename to the loop param happens.
+        if (node.filterPredicate) names.add(node.filterPredicate.param)
+        for (const child of node.children) visit(child)
+        if (node.childComponent) {
+          for (const child of node.childComponent.children) visit(child)
+        }
+        for (const nested of node.nestedComponents ?? []) {
+          for (const child of nested.children) visit(child)
+        }
+        for (const frag of node.flatMapCallback?.fragments ?? []) {
+          visit(frag.ir)
+        }
+        break
+      case 'conditional':
+        visit(node.whenTrue)
+        visit(node.whenFalse)
+        break
+      case 'if-statement':
+        visit(node.consequent)
+        if (node.alternate) visit(node.alternate)
+        break
+      case 'text':
+      case 'expression':
+      case 'slot':
+        break
+    }
+  }
+  visit(ir.root)
+  return names
+}

package/src/adapters/parsed-expr-emitter.ts

@@ -228,6 +228,15 @@ export function isStringTypedOperand(expr: ParsedExpr, isStringName: (n: string)
   if (expr.kind === 'member' && expr.object.kind === 'identifier' && expr.object.name === 'props') {
     return isStringName(expr.property)
   }
+  // A bare identifier (#2212): a destructured prop param or a same-file
+  // local const, string-typed per the caller's `isStringName` set — each
+  // adapter's `collectStringValueNames` already tracks `propsParams`, so a
+  // component's own `{ a, b }: { a: string; b: string }` destructure was
+  // only unreachable here for lack of this arm; extending
+  // `collectStringValueNames` to also walk `ir.metadata.localConstants`
+  // (adapter-side change) closes the "two same-file string consts" shape
+  // the same way.
+  if (expr.kind === 'identifier') return isStringName(expr.name)
   if (expr.kind === 'binary' && expr.op === '+') {
     return isStringTypedOperand(expr.left, isStringName) || isStringTypedOperand(expr.right, isStringName)
   }

package/src/analyzer.ts

@@ -50,6 +50,11 @@ export function needsTypeBasedDetection(source: string): boolean {
   if (REACTIVE_BRAND_PACKAGES.some(pkg => source.includes(pkg))) return true
   // BF023/BF024 nullable-key check needs getTypeAtLocation() on the key expression.
   if (/\.map\s*\(/.test(source)) return true
+  // createSelector's returned accessor is Reactive<>-branded like a library
+  // accessor above — a selector call outside any `.map()` (no loop in the
+  // file at all) would otherwise skip the TypeChecker entirely and miss the
+  // brand.
+  if (source.includes('createSelector')) return true
   return false
 }
 
@@ -1828,6 +1833,7 @@ function collectLocalDeclarations(root: ts.Node): Set<string> {
 // and are emitted by the compiler for 'use client' components.
 const CLIENT_EXPORTS = new Set([
   'createSignal', 'createEffect', 'createDisposableEffect', 'createMemo',
+  'createSelector',
   'createRoot', 'onCleanup', 'onMount', 'untrack', 'batch', 'splitProps',
   'forwardProps', 'unwrap', '__slot',
   'createContext', 'useContext', 'provideContext',
@@ -3034,14 +3040,16 @@ function extractProps(param: ts.ParameterDeclaration, ctx: AnalyzerContext): voi
           element.propertyName && ts.isIdentifier(element.propertyName)
             ? element.propertyName.text
             : localName
-        const resolvedType: TypeInfo =
-          memberTypes?.get(sourcePropName) ?? { kind: 'unknown', raw: 'unknown' }
+        const member = memberTypes?.get(sourcePropName)
+        const resolvedType: TypeInfo = member?.type ?? { kind: 'unknown', raw: 'unknown' }
 
         const defaultContainsArrow = element.initializer ? nodeContainsArrow(element.initializer) : false
         ctx.propsParams.push({
           name: localName,
           type: resolvedType,
-          optional: !!element.initializer,
+          // The type's `?` and a destructure default (`{ x = 1 }`) both mean
+          // the caller may omit the prop.
+          optional: !!member?.optional || !!element.initializer,
           defaultValue,
           defaultContainsArrow: defaultContainsArrow || undefined,
         })
@@ -3124,18 +3132,21 @@ function collectKeysFromMembers(
 }
 
 /**
- * Build a property-name -> resolved TypeInfo map from a props type annotation,
- * for destructured params (`{ value }: Props`) so they carry the same per-prop
- * types the props-object path (`props: Props`) already resolves. Returns null
- * for external/unresolvable types.
+ * Build a property-name -> { type, optional } map from a props type
+ * annotation, for destructured params (`{ value }: Props`) so they carry the
+ * same per-prop TypeInfo and optionality the props-object path
+ * (`props: Props`) already resolves (#2150, #2259). Returns null for
+ * external/unresolvable types.
  *
- * Scope (deliberately narrow — targets the panic in issue #2150):
- * - Only REQUIRED members are resolved. Optional members (`value?: T`) are left
- *   out so they keep degrading to `unknown` -> `interface{}`: typed adapters
- *   rely on that nillable field to omit an unset optional attribute
- *   (`{{if ne .X nil}}` in Go), which a concrete zero value could not express.
- * - Only PRIMITIVE members (string/number/boolean) are resolved. Those are the
- *   types that otherwise produce an unchecked scalar assertion (`in.X.(int)`)
+ * Scope:
+ * - Optionality is collected for EVERY member — it feeds the type's `?` into
+ *   `propsParams[].optional` alongside a destructure default. Optional
+ *   members resolve like required ones: typed adapters no longer need them
+ *   degraded to `unknown` -> `interface{}` for attribute omission, because
+ *   #2252's nullish-flip machinery supplies the nillable representation
+ *   exactly where absence is semantically observable (#2259).
+ * - Only PRIMITIVE members (string/number/boolean) resolve a type. Those are
+ *   the types that otherwise produce an unchecked scalar assertion (`in.X.(int)`)
  *   that panics. Arrays/objects/functions are left as `unknown` because typed
  *   adapters lower them through interface{}-based helpers (`bf_flat`, spread,
  *   `bf_json`); giving them concrete types would break that lowering and is a
@@ -3144,19 +3155,22 @@ function collectKeysFromMembers(
 function collectMemberTypes(
   typeNode: ts.TypeNode,
   ctx: AnalyzerContext
-): Map<string, TypeInfo> | null {
+): Map<string, { type: TypeInfo | null; optional: boolean }> | null {
   const isResolvablePrimitive = (info: TypeInfo): boolean =>
     info.kind === 'primitive' &&
     (info.primitive === 'string' || info.primitive === 'number' || info.primitive === 'boolean')
 
-  const fromMembers = (members: ts.NodeArray<ts.TypeElement>): Map<string, TypeInfo> => {
-    const map = new Map<string, TypeInfo>()
+  const fromMembers = (
+    members: ts.NodeArray<ts.TypeElement>
+  ): Map<string, { type: TypeInfo | null; optional: boolean }> => {
+    const map = new Map<string, { type: TypeInfo | null; optional: boolean }>()
     for (const member of members) {
-      if (ts.isPropertySignature(member) && member.name && member.type && !member.questionToken) {
-        const info = typeNodeToTypeInfo(member.type, ctx.sourceFile)
-        if (info && isResolvablePrimitive(info)) {
-          map.set(member.name.getText(ctx.sourceFile), info)
-        }
+      if (ts.isPropertySignature(member) && member.name) {
+        const info = member.type ? typeNodeToTypeInfo(member.type, ctx.sourceFile) : null
+        map.set(member.name.getText(ctx.sourceFile), {
+          type: info && isResolvablePrimitive(info) ? info : null,
+          optional: !!member.questionToken,
+        })
       }
     }
     return map

package/src/expression-parser.ts

@@ -153,6 +153,39 @@ export type ParsedExpr =
     }
   | { kind: 'unsupported'; raw: string; reason: string }
 
+/**
+ * Runtime registry of every `ParsedExpr` kind — the denominator for
+ * coverage bookkeeping (`spec/subset-conformance.md`): a conformance
+ * fixture's exercised-kind set is computed against this list, and the
+ * ledger-floor meta-test requires each entry to be exercised or
+ * explicitly excluded.
+ */
+export const PARSED_EXPR_KINDS = [
+  'identifier',
+  'literal',
+  'call',
+  'member',
+  'index-access',
+  'binary',
+  'unary',
+  'conditional',
+  'logical',
+  'template-literal',
+  'arrow',
+  'regex',
+  'array-literal',
+  'object-literal',
+  'array-method',
+  'unsupported',
+] as const satisfies ReadonlyArray<ParsedExpr['kind']>
+
+// Exhaustiveness pin: adding a `ParsedExpr` kind without listing it in
+// `PARSED_EXPR_KINDS` fails to compile here (the same drift defence the
+// exhaustive adapter switches provide for behaviour).
+type MissingFromKindRegistry = Exclude<ParsedExpr['kind'], (typeof PARSED_EXPR_KINDS)[number]>
+const _kindRegistryIsExhaustive: MissingFromKindRegistry extends never ? true : never = true
+void _kindRegistryIsExhaustive
+
 /**
  * One property of an `object-literal` `ParsedExpr`. The key is the
  * resolved (non-computed) property name — for `{ a: 1 }` and shorthand