@barefootjs/jsx 0.19.1 → 0.21.0

package/src/__tests__/date-lowering.test.ts

@@ -0,0 +1,232 @@
+/**
+ * `Date` lowering plugin (#2274) — the first catalogued rich-type lowering
+ * built on top of the #2273 refusal seam. Covers the matcher's own
+ * recognition rules directly (mirrors `query-href-recognition.test.ts`'s
+ * `metadata()` extraction), plus the BF021-exemption integration promised by
+ * `rich-type-refusal.ts`'s module doc: a call the registry claims must not
+ * also fire BF021, while an un-catalogued Date method on the same receiver
+ * still does.
+ */
+import { describe, test, expect, afterEach } from 'bun:test'
+import { compileJSX, type ComponentIR } from '../index'
+import { TestAdapter } from '../adapters/test-adapter'
+import { parseExpression, type ParsedExpr } from '../expression-parser'
+import { datePlugin, DATE_METHODS } from '../date-lowering'
+import { registerLoweringPlugin, __resetLoweringPluginsForTest, getLoweringPlugins } from '../lowering-registry'
+import { ErrorCodes } from '../errors'
+
+function metadata(src: string): ComponentIR['metadata'] {
+  const result = compileJSX(src.trimStart(), 'T.tsx', { adapter: new TestAdapter(), outputIR: true })
+  const ir = JSON.parse(result.files.find((f) => f.type === 'ir')!.content) as ComponentIR
+  return ir.metadata
+}
+
+/** Parse a call expression source and return its callee + args, the exact
+ * shape a `LoweringMatcher` receives. */
+function callParts(expr: string): { callee: ParsedExpr; args: ParsedExpr[] } {
+  const parsed = parseExpression(expr)
+  if (parsed.kind !== 'call') throw new Error(`expected a call expression, got ${parsed.kind}`)
+  return { callee: parsed.callee, args: parsed.args }
+}
+
+describe('DATE_METHODS catalogue', () => {
+  test('is exactly the 8 zero-arg Date.prototype accessors the spec entry names', () => {
+    expect([...DATE_METHODS].sort()).toEqual(
+      [
+        'getUTCFullYear',
+        'getUTCMonth',
+        'getUTCDate',
+        'getUTCHours',
+        'getUTCMinutes',
+        'getUTCSeconds',
+        'getTime',
+        'toISOString',
+      ].sort(),
+    )
+  })
+})
+
+describe('datePlugin matcher recognition (#2274)', () => {
+  test('props-object member chain (props.createdAt.toISOString()) matches', () => {
+    const md = metadata(`
+      export function Foo(props: { createdAt: Date }) {
+        return <div>{props.createdAt.toISOString()}</div>
+      }
+    `)
+    const matcher = datePlugin.prepare(md)
+    expect(matcher).not.toBeNull()
+    const { callee, args } = callParts('props.createdAt.toISOString()')
+    expect(matcher!(callee, args)).toEqual({
+      kind: 'helper-call',
+      helper: 'date',
+      args: [(callee as { object: ParsedExpr }).object, { kind: 'literal', value: 'toISOString', literalType: 'string' }],
+    })
+  })
+
+  test('destructured Date prop (createdAt.getUTCFullYear()) matches', () => {
+    const md = metadata(`
+      export function Foo({ createdAt }: { createdAt: Date }) {
+        return <div>{createdAt.getUTCFullYear()}</div>
+      }
+    `)
+    const matcher = datePlugin.prepare(md)
+    expect(matcher).not.toBeNull()
+    const { callee, args } = callParts('createdAt.getUTCFullYear()')
+    expect(matcher!(callee, args)).toEqual({
+      kind: 'helper-call',
+      helper: 'date',
+      args: [(callee as { object: ParsedExpr }).object, { kind: 'literal', value: 'getUTCFullYear', literalType: 'string' }],
+    })
+  })
+
+  test('renamed destructured Date prop ({ createdAt: c }) resolves via the source name', () => {
+    const md = metadata(`
+      export function Foo({ createdAt: c }: { createdAt: Date }) {
+        return <div>{c.getTime()}</div>
+      }
+    `)
+    const matcher = datePlugin.prepare(md)
+    expect(matcher).not.toBeNull()
+    const { callee, args } = callParts('c.getTime()')
+    expect(matcher!(callee, args)).toEqual({
+      kind: 'helper-call',
+      helper: 'date',
+      args: [(callee as { object: ParsedExpr }).object, { kind: 'literal', value: 'getTime', literalType: 'string' }],
+    })
+  })
+
+  test('#2274: destructured Date prop now carries a real propsParams TypeInfo (analyzer widening)', () => {
+    // Pre-widening this degraded to { kind: 'unknown', raw: 'unknown' }
+    // (analyzer.ts's #2150 primitives-only gate) — resolveReceiverType's
+    // destructured path reads the type from propsType, not propsParams, so
+    // the widening isn't load-bearing for the matcher above, but propsParams
+    // is itself observable IR metadata this plugin's existence is meant to
+    // unlock (see analyzer.ts's docstring on `isResolvablePrimitive`).
+    const md = metadata(`
+      export function Foo({ createdAt }: { createdAt: Date }) {
+        return <div>{createdAt.toISOString()}</div>
+      }
+    `)
+    const param = md.propsParams.find((p) => p.name === 'createdAt')
+    expect(param?.type.kind).toBe('interface')
+    expect(param?.type.raw).toBe('Date')
+  })
+
+  test('toLocaleDateString is not a catalogued method — declines (falls back to BF021)', () => {
+    const md = metadata(`
+      export function Foo({ createdAt }: { createdAt: Date }) {
+        return <div>{createdAt.toLocaleDateString()}</div>
+      }
+    `)
+    const matcher = datePlugin.prepare(md)
+    expect(matcher).not.toBeNull() // Date IS reachable — the gate stays active …
+    const { callee, args } = callParts('createdAt.toLocaleDateString()')
+    expect(matcher!(callee, args)).toBeNull() // … but this specific method declines.
+  })
+
+  test('a catalogued method name called with an argument declines (zero-arg only)', () => {
+    const md = metadata(`
+      export function Foo({ createdAt }: { createdAt: Date }) {
+        return <div>{createdAt.getTime()}</div>
+      }
+    `)
+    const matcher = datePlugin.prepare(md)
+    expect(matcher).not.toBeNull()
+    const { callee, args } = callParts('createdAt.getTime(1)')
+    expect(matcher!(callee, args)).toBeNull()
+  })
+
+  test('a non-Date receiver never activates the plugin (prepare declines entirely)', () => {
+    const md = metadata(`
+      export function Foo({ createdAt }: { createdAt: string }) {
+        return <div>{createdAt.toUpperCase()}</div>
+      }
+    `)
+    expect(datePlugin.prepare(md)).toBeNull()
+  })
+
+  test('a component with no props type at all never activates the plugin', () => {
+    const md = metadata(`
+      export function Foo() {
+        return <div>static</div>
+      }
+    `)
+    expect(datePlugin.prepare(md)).toBeNull()
+  })
+})
+
+describe('BF021 exemption via the real datePlugin (#2274 seam)', () => {
+  afterEach(() => {
+    __resetLoweringPluginsForTest(getLoweringPlugins().filter((p) => p.name !== 'date'))
+  })
+
+  function bf021Count(source: string): number {
+    registerLoweringPlugin(datePlugin)
+    const result = compileJSX(source.trimStart(), 'Test.tsx', { adapter: new TestAdapter() })
+    return result.errors.filter((e) => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN).length
+  }
+
+  test('a catalogued call the plugin claims fires zero BF021', () => {
+    expect(
+      bf021Count(`
+        export function Foo({ createdAt }: { createdAt: Date }) {
+          return <div>{createdAt.toISOString()}</div>
+        }
+      `),
+    ).toBe(0)
+  })
+
+  test('an un-catalogued Date method on the same prop still fires BF021', () => {
+    expect(
+      bf021Count(`
+        export function Foo({ createdAt }: { createdAt: Date }) {
+          return <div>{createdAt.toLocaleDateString()}</div>
+        }
+      `),
+    ).toBe(1)
+  })
+})
+
+describe('client-JS lowering (#2292)', () => {
+  function clientJs(src: string): string {
+    const result = compileJSX(src.trimStart(), 'T.tsx', { adapter: new TestAdapter() })
+    return result.files.find((f) => f.type === 'clientJs')!.content
+  }
+
+  test('lowers a Date-typed prop accessor call to the date() runtime helper', () => {
+    const js = clientJs(`
+      export function Foo({ createdAt }: { createdAt: Date }) {
+        return <div>{createdAt.toISOString()}</div>
+      }
+    `)
+    expect(js).toContain('date(_p.createdAt, "toISOString")')
+    // auto-imported from the runtime barrel (imports.ts RUNTIME_IMPORT_CANDIDATES)
+    expect(js).toMatch(/import\s*\{[^}]*\bdate\b[^}]*\}\s*from\s*'@barefootjs\/client\/runtime'/)
+  })
+
+  test('leaves a non-Date receiver method call raw (parity: only what datePlugin claims)', () => {
+    const js = clientJs(`
+      export function Foo({ label }: { label: string }) {
+        return <div>{label.toUpperCase()}</div>
+      }
+    `)
+    expect(js).not.toContain('date(')
+    expect(js).toContain('toUpperCase()')
+  })
+
+  test('protects a template-literal static segment that matches the call text (#2294)', () => {
+    // The real call is in the ${…} interpolation; an identical-looking run
+    // of text sits in the static segment. Template-aware string protection
+    // must keep the non-global .replace from rewriting the static text
+    // before the real call site (Copilot review).
+    const js = clientJs(`
+      export function Foo({ createdAt }: { createdAt: Date }) {
+        return <div>{\`createdAt.toISOString() = \${createdAt.toISOString()}\`}</div>
+      }
+    `)
+    // the real (interpolated) call is lowered
+    expect(js).toContain('date(_p.createdAt, "toISOString")')
+    // the static segment is preserved verbatim, not rewritten to date(...)
+    expect(js).toContain('createdAt.toISOString() = ')
+  })
+})

package/src/__tests__/nested-loop-reactive-attrs.test.ts

@@ -342,4 +342,60 @@ describe('reactive attributes inside a nested .map() body (#135)', () => {
     expect(content).toMatch(/createEffect\(\(\) => \{[\s\S]*?\.textContent = String\(panel\(\)\.text\)/)
     expect(content).toContain("setAttribute('class'")
   })
+
+  test('reactive text child of a triple-nested inner loop read through an opaque helper gets an update effect (#2282)', () => {
+    // #2264 fixed the case where `classifyReactivity` proves the text
+    // reactive via the loop-param path (bare `panel.text`). It left a
+    // sibling gap: `collectLoopChildReactiveTexts` had no Solid-style
+    // AST-flag fallback, so a text read through an opaque helper the
+    // classifier can't see through (`labelAt(pi)` where `const labelAt =
+    // (i) => labels()[i]`) still silently dropped its update effect — while
+    // `collectLoopChildReactiveAttrs` already had that fallback (#1673,
+    // see `reactive-attrs-in-map.test.ts`), so the sibling `className`
+    // effect on the SAME element kept working. Reported as #2282 ("child
+    // inlined into a parent island drops the innermost reactive text
+    // effect"); the issue's own literal `{panel.text}` repro snippet
+    // doesn't reproduce it (that shape is exactly what #2264 already
+    // fixed) — this test pins the actual asymmetry root-caused during
+    // investigation, using the opaque-helper shape that does reproduce.
+    const source = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+
+      type Panel = { id: number; cls: string }
+      type Band = { id: string; panels: Panel[] }
+      type Page = { id: string; bands: Band[] }
+
+      export function Doc2() {
+        const [pages] = createSignal<Page[]>([])
+        const [labels] = createSignal<string[]>([])
+        const labelAt = (i: number) => labels()[i]
+        return (
+          <div>
+            {pages().map(page => (
+              <div key={page.id}>
+                {page.bands.map(band => (
+                  <div key={band.id}>
+                    {band.panels.map((panel, pi) => (
+                      <div key={panel.id} className={panel.cls}>{labelAt(pi)}</div>
+                    ))}
+                  </div>
+                ))}
+              </div>
+            ))}
+          </div>
+        )
+      }
+    `
+    const result = compileJSX(source, 'Doc2.tsx', { adapter })
+    expect(result.errors).toHaveLength(0)
+    const content = result.files.find((f) => f.type === 'clientJs')!.content
+
+    // The helper call must appear inside a createEffect alongside the
+    // textContent write — `labelAt(` also appears in the static template
+    // clone, so asserting it independently would pass even with the
+    // effect missing (the exact regression here).
+    expect(content).toMatch(/createEffect\(\(\) => \{[\s\S]*?\.textContent = String\(labelAt\(pi\)\)/)
+    expect(content).toContain("setAttribute('class'")
+  })
 })

package/src/__tests__/rich-type-method-refusal.test.ts

@@ -0,0 +1,323 @@
+/**
+ * Rich-type method-call refusal (BF021, #2273).
+ *
+ * A method call on a prop typed as a built-in host rich type (`Date`,
+ * `Map`, …) has no catalogued lowering in any adapter — left unchecked it
+ * transliterates into the target template's own syntax and dies at request
+ * time. `checkRichTypeMethodCalls` (rich-type-refusal.ts) is wired into
+ * `compileJSX` (not the bare analyzer/jsxToIR pipeline other BF021 tests in
+ * this directory use), so these tests go through `compileJSX` directly.
+ *
+ * This suite intentionally exercises the refusal against an EMPTY plugin
+ * registry (only the "registry-claimed call is exempt" test opts a plugin
+ * back in, and cleans up after itself) — `Date`/`Map`/… calls here must
+ * still have no catalogued lowering for the fires/silent split below to mean
+ * anything. `bun test` runs every file in one process, and a sibling file
+ * that imports the package entry (`../index`) registers the real built-ins
+ * (`queryHref`, `date`, #2274) as a global side effect — including `date`,
+ * which legitimately claims `.toISOString()`. Snapshot + clear + restore
+ * around the whole file so this suite's result never depends on which other
+ * test files happened to run first in the same process.
+ */
+
+import { describe, test, expect, beforeAll, afterAll } from 'bun:test'
+import { compileJSX } from '../compiler'
+import { ErrorCodes } from '../errors'
+import { TestAdapter } from '../adapters/test-adapter'
+import { registerLoweringPlugin, __resetLoweringPluginsForTest, getLoweringPlugins, type LoweringPlugin } from '../lowering-registry'
+
+const adapter = new TestAdapter()
+
+let savedPlugins: readonly LoweringPlugin[]
+beforeAll(() => {
+  savedPlugins = getLoweringPlugins()
+  __resetLoweringPluginsForTest([])
+})
+afterAll(() => {
+  __resetLoweringPluginsForTest(savedPlugins)
+})
+
+function bf021(source: string, filePath = 'Test.tsx') {
+  const result = compileJSX(source, filePath, { adapter })
+  return result.errors.filter((e) => e.code === ErrorCodes.UNSUPPORTED_JSX_PATTERN)
+}
+
+describe('rich-type method-call refusal — fires (BF021)', () => {
+  test('inline-destructured Date in text position', () => {
+    const errors = bf021(`
+      export function Foo({ createdAt }: { createdAt: Date }) {
+        return <div>{createdAt.toISOString()}</div>
+      }
+    `)
+    expect(errors).toHaveLength(1)
+    expect(errors[0].message).toContain("'.toISOString()'")
+    expect(errors[0].message).toContain("'createdAt'")
+    expect(errors[0].message).toContain("'Date'")
+  })
+
+  test('props-object member chain in attribute position', () => {
+    const errors = bf021(`
+      export function Foo(props: { d: Date }) {
+        return <div data-year={props.d.getUTCFullYear()} />
+      }
+    `)
+    expect(errors).toHaveLength(1)
+    expect(errors[0].message).toContain("'.getUTCFullYear()'")
+    expect(errors[0].message).toContain("'props.d'")
+    expect(errors[0].message).toContain("'Date'")
+  })
+
+  test('named interface Props Date field (typeDefinitions deref)', () => {
+    const errors = bf021(`
+      interface Props { createdAt: Date }
+      export function Foo({ createdAt }: Props) {
+        return <div>{createdAt.getFullYear()}</div>
+      }
+    `)
+    expect(errors).toHaveLength(1)
+    expect(errors[0].message).toContain("'.getFullYear()'")
+    expect(errors[0].message).toContain("'createdAt'")
+    expect(errors[0].message).toContain("'Date'")
+  })
+
+  test('optional-chained call', () => {
+    const errors = bf021(`
+      export function Foo({ d }: { d: Date | undefined }) {
+        return <div>{d?.toISOString()}</div>
+      }
+    `)
+    expect(errors).toHaveLength(1)
+    expect(errors[0].message).toContain("'.toISOString()'")
+  })
+
+  test('Date | null union resolves to Date', () => {
+    const errors = bf021(`
+      export function Foo({ d }: { d: Date | null }) {
+        return <div>{d.toISOString()}</div>
+      }
+    `)
+    expect(errors).toHaveLength(1)
+    expect(errors[0].message).toContain("'Date'")
+  })
+
+  test('loop-item member (items.map(i => i.at.getTime()))', () => {
+    const errors = bf021(`
+      export function Foo({ items }: { items: { at: Date }[] }) {
+        return <ul>{items.map(i => <li>{i.at.getTime()}</li>)}</ul>
+      }
+    `)
+    expect(errors).toHaveLength(1)
+    expect(errors[0].message).toContain("'.getTime()'")
+    // A loop item is prop-DERIVED but not itself a prop — the message must
+    // not call it one (only bare / props-object receivers earn "prop").
+    expect(errors[0].message).toContain("on 'i.at'")
+    expect(errors[0].message).not.toContain("prop 'i.at'")
+    expect(errors[0].message).toContain("'Date'")
+  })
+
+  test('renamed destructured prop ({ createdAt: c })', () => {
+    const errors = bf021(`
+      export function Foo({ createdAt: c }: { createdAt: Date }) {
+        return <div>{c.toISOString()}</div>
+      }
+    `)
+    expect(errors).toHaveLength(1)
+    expect(errors[0].message).toContain("'.toISOString()'")
+    expect(errors[0].message).toContain("prop 'c'")
+    expect(errors[0].message).toContain("'Date'")
+  })
+
+  test('conditional-branch call without @client', () => {
+    const errors = bf021(`
+      export function Foo({ d }: { d: Date | null }) {
+        return <div>{d && <span>{d.toISOString()}</span>}</div>
+      }
+    `)
+    expect(errors).toHaveLength(1)
+    expect(errors[0].message).toContain("'.toISOString()'")
+  })
+
+  test('two distinct receivers at the same expression report separately', () => {
+    const errors = bf021(`
+      export function Foo({ a, b }: { a: Date; b: Date }) {
+        return <div>{a.getTime() + b.getTime()}</div>
+      }
+    `)
+    expect(errors).toHaveLength(2)
+    expect(errors[0].message).toContain("prop 'a'")
+    expect(errors[1].message).toContain("prop 'b'")
+  })
+
+  test('Date in component-prop position', () => {
+    const errors = bf021(`
+      function Bar(props: { value: string }) {
+        return <div>{props.value}</div>
+      }
+      export function Foo({ createdAt }: { createdAt: Date }) {
+        return <Bar value={createdAt.toISOString()} />
+      }
+    `)
+    expect(errors).toHaveLength(1)
+    expect(errors[0].message).toContain("'.toISOString()'")
+    expect(errors[0].message).toContain("'createdAt'")
+  })
+
+  test('Map.get() (broad host-type list)', () => {
+    const errors = bf021(`
+      export function Foo({ m }: { m: Map<string, string> }) {
+        return <div>{m.get('x')}</div>
+      }
+    `)
+    expect(errors).toHaveLength(1)
+    expect(errors[0].message).toContain("'.get()'")
+    expect(errors[0].message).toContain("'Map'")
+  })
+
+  test('diagnostic carries the @client suggestion', () => {
+    const errors = bf021(`
+      export function Foo({ createdAt }: { createdAt: Date }) {
+        return <div>{createdAt.toISOString()}</div>
+      }
+    `)
+    expect(errors[0].severity).toBe('error')
+    expect(errors[0].suggestion?.message).toContain('@client')
+  })
+})
+
+describe('rich-type method-call refusal — silent (no BF021)', () => {
+  test('/* @client */-prefixed Date call', () => {
+    const errors = bf021(`
+      export function Foo({ createdAt }: { createdAt: Date }) {
+        return <div>{/* @client */ createdAt.toISOString()}</div>
+      }
+    `)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('/* @client */-wrapped conditional branch', () => {
+    const errors = bf021(`
+      export function Foo({ d }: { d: Date | null }) {
+        return <div>{/* @client */ d && <span>{d.toISOString()}</span>}</div>
+      }
+    `)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('module const sharing a propsType field name (object-props mode)', () => {
+    const errors = bf021(`
+      const version = 'v1'
+      export function Foo(props: { version: Map<string, string> }) {
+        return <div>{version.toUpperCase()}</div>
+      }
+    `)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('string method on string prop', () => {
+    const errors = bf021(`
+      export function Foo({ s }: { s: string }) {
+        return <div>{s.toUpperCase()}</div>
+      }
+    `)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('array method on array prop', () => {
+    const errors = bf021(`
+      export function Foo({ items }: { items: string[] }) {
+        return <div>{items.join(',')}</div>
+      }
+    `)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('untyped receiver (no type annotation)', () => {
+    const errors = bf021(`
+      export function Foo({ d }) {
+        return <div>{d.toISOString()}</div>
+      }
+    `)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('generic type-parameter receiver', () => {
+    const errors = bf021(`
+      export function Foo<T>({ d }: { d: T }) {
+        return <div>{d.toISOString()}</div>
+      }
+    `)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('imported named type receiver', () => {
+    const errors = bf021(`
+      import type { Widget } from './widget'
+      export function Foo({ w }: { w: Widget }) {
+        return <div>{w.render()}</div>
+      }
+    `)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('signal getter call result (d().toISOString())', () => {
+    const errors = bf021(`
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function Foo() {
+        const [d, setD] = createSignal(new Date())
+        return <div>{d().toISOString()}</div>
+      }
+    `)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('local-function call (not a member call on the receiver)', () => {
+    const errors = bf021(`
+      function formatDate(x: Date): string { return x.toString() }
+      export function Foo({ createdAt }: { createdAt: Date }) {
+        return <div>{formatDate(createdAt)}</div>
+      }
+    `)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('.length non-call access', () => {
+    const errors = bf021(`
+      export function Foo({ items }: { items: string[] }) {
+        return <div>{items.length}</div>
+      }
+    `)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('in-file interface Date shadow', () => {
+    const errors = bf021(`
+      interface Date { iso: string }
+      export function Foo({ d }: { d: Date }) {
+        return <div>{d.toISOString()}</div>
+      }
+    `)
+    expect(errors).toHaveLength(0)
+  })
+
+  test('registry-claimed call is exempt (#2274 seam)', () => {
+    const samplePlugin: LoweringPlugin = {
+      name: 'sample-date-lowering',
+      prepare: () => (callee, _args) =>
+        callee.kind === 'member' && !callee.computed && callee.property === 'toISOString'
+          ? { kind: 'helper-call', helper: 'isoDate', args: [] }
+          : null,
+    }
+    registerLoweringPlugin(samplePlugin)
+    try {
+      const errors = bf021(`
+        export function Foo({ createdAt }: { createdAt: Date }) {
+          return <div>{createdAt.toISOString()}</div>
+        }
+      `)
+      expect(errors).toHaveLength(0)
+    } finally {
+      __resetLoweringPluginsForTest(getLoweringPlugins().filter((p) => p.name !== 'sample-date-lowering'))
+    }
+  })
+})

package/src/analyzer.ts

@@ -24,6 +24,8 @@ import {
   collectReactiveGetterNames,
 } from './analyzer-context.ts'
 import { createError, createWarning, ErrorCodes } from './errors.ts'
+import { baseTypeName } from './rich-type-evidence.ts'
+import { CATALOGUED_RICH_TYPE_NAMES } from './date-lowering.ts'
 import path from 'node:path'
 import fs from 'node:fs'
 
@@ -3068,6 +3070,8 @@ function extractProps(param: ts.ParameterDeclaration, ctx: AnalyzerContext): voi
           optional: !!member?.optional || !!element.initializer,
           defaultValue,
           defaultContainsArrow: defaultContainsArrow || undefined,
+          // Only aliased bindings carry the source key — see ParamInfo.sourceName.
+          ...(sourcePropName !== localName && { sourceName: sourcePropName }),
         })
       }
     }
@@ -3172,9 +3176,24 @@ function collectMemberTypes(
   typeNode: ts.TypeNode,
   ctx: AnalyzerContext
 ): Map<string, { type: TypeInfo | null; optional: boolean }> | null {
+  // #2150 originally restricted this gate to string/number/boolean only,
+  // because a non-primitive TypeInfo here used to mean "the typed adapters
+  // will emit an unchecked scalar assertion (`in.X.(int)`) that panics" for
+  // a shape the template layer has no representation for. That reasoning
+  // does NOT extend to a rich type with a CATALOGUED lowering (#2274: `Date`
+  // → the `date` helper): its propsParams TypeInfo is consumed only as
+  // call-site evidence for `resolveReceiverType` (rich-type-evidence.ts) —
+  // never emitted as a concrete field type (`typeInfoToGo`'s `interface`
+  // case falls through to `interface{}` for an unbacked host name exactly
+  // as `unknown` already did) — so there is no assertion to panic. Gating on
+  // `CATALOGUED_RICH_TYPE_NAMES` specifically (not `HOST_RICH_TYPE_NAMES`
+  // wholesale) keeps an un-catalogued rich type (`Map`, `Set`, …) at
+  // `unknown`, i.e. avoids resurrecting the #2150 mistake for a shape no
+  // lowering plugin exists for yet.
   const isResolvablePrimitive = (info: TypeInfo): boolean =>
-    info.kind === 'primitive' &&
-    (info.primitive === 'string' || info.primitive === 'number' || info.primitive === 'boolean')
+    (info.kind === 'primitive' &&
+      (info.primitive === 'string' || info.primitive === 'number' || info.primitive === 'boolean')) ||
+    (info.kind === 'interface' && CATALOGUED_RICH_TYPE_NAMES.has(baseTypeName(info.raw)))
 
   const fromMembers = (
     members: ts.NodeArray<ts.TypeElement>

package/src/builtin-lowering-plugins.ts

@@ -16,6 +16,7 @@ import type { LoweringPlugin } from './lowering-registry.ts'
 import { registerLoweringPlugin } from './lowering-registry.ts'
 import { queryHrefLocalNames } from './adapters/env-signal.ts'
 import { matchQueryHrefCall } from './query-href-lowering.ts'
+import { datePlugin } from './date-lowering.ts'
 
 /**
  * `queryHref(base, { … })` — the pure URL-query builder (#2042). Its runtime
@@ -41,7 +42,7 @@ export const queryHrefPlugin: LoweringPlugin = {
 }
 
 /** Every plugin the compiler ships and applies by default. */
-export const BUILTIN_LOWERING_PLUGINS: readonly LoweringPlugin[] = [queryHrefPlugin]
+export const BUILTIN_LOWERING_PLUGINS: readonly LoweringPlugin[] = [queryHrefPlugin, datePlugin]
 
 /**
  * Register the built-in plugins into the shared registry. Called for its side