npm - @barefootjs/jsx - Versions diffs - 0.13.0 → 0.15.0 - Mend

@barefootjs/jsx 0.13.0 → 0.15.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (46) hide show

package/dist/adapters/env-signal.d.ts +40 -0
package/dist/adapters/env-signal.d.ts.map +1 -0
package/dist/adapters/parsed-expr-emitter.d.ts +2 -1
package/dist/adapters/parsed-expr-emitter.d.ts.map +1 -1
package/dist/analyzer.d.ts.map +1 -1
package/dist/augment-inherited-props.d.ts +42 -1
package/dist/augment-inherited-props.d.ts.map +1 -1
package/dist/builtins.d.ts +33 -0
package/dist/builtins.d.ts.map +1 -0
package/dist/compiler.d.ts.map +1 -1
package/dist/errors.d.ts +1 -0
package/dist/errors.d.ts.map +1 -1
package/dist/expression-parser.d.ts +48 -1
package/dist/expression-parser.d.ts.map +1 -1
package/dist/index.d.ts +5 -4
package/dist/index.d.ts.map +1 -1
package/dist/index.js +411 -26
package/dist/ir-to-client-js/imports.d.ts.map +1 -1
package/dist/jsx-to-ir.d.ts.map +1 -1
package/dist/profiler.d.ts +37 -0
package/dist/profiler.d.ts.map +1 -1
package/dist/ssr-defaults.d.ts.map +1 -1
package/dist/types.d.ts +16 -0
package/dist/types.d.ts.map +1 -1
package/package.json +2 -2
package/src/__tests__/compiler-stress-1244.test.ts +4 -2
package/src/__tests__/expression-parser.test.ts +92 -1
package/src/__tests__/ir-async.test.ts +8 -0
package/src/__tests__/ir-builtin-import-scope.test.ts +188 -0
package/src/__tests__/ir-region.test.ts +86 -0
package/src/__tests__/profiler.test.ts +69 -0
package/src/__tests__/ssr-defaults.test.ts +25 -0
package/src/adapters/env-signal.ts +75 -0
package/src/adapters/parsed-expr-emitter.ts +11 -0
package/src/analyzer.ts +9 -0
package/src/augment-inherited-props.ts +170 -2
package/src/builtins.ts +63 -0
package/src/compiler.ts +6 -2
package/src/errors.ts +10 -0
package/src/expression-parser.ts +156 -2
package/src/index.ts +5 -2
package/src/ir-to-client-js/imports.ts +5 -0
package/src/jsx-to-ir.ts +189 -8
package/src/profiler.ts +63 -0
package/src/ssr-defaults.ts +55 -17
package/src/types.ts +16 -0

package/src/__tests__/ir-builtin-import-scope.test.ts ADDED Viewed

@@ -0,0 +1,188 @@
+import { describe, test, expect } from 'bun:test'
+import { analyzeComponent } from '../analyzer'
+import { jsxToIR } from '../jsx-to-ir'
+import { ErrorCodes } from '../errors'
+import { stripClientBuiltinImports } from '../builtins'
+import type { IRAsync, IRElement, IRComponent, ImportInfo } from '../types'
+// Import-scoped recognition for the compile-away built-ins `<Async>` /
+// `<Region>` (#1915). The compiler recognises them by their
+// `@barefootjs/client` import — never by a bare capitalized tag name — so a
+// user's own component does not collide with the built-in, and the import is
+// elided on emit.
+function ir(source: string, path = 'Comp.tsx') {
+  const ctx = analyzeComponent(source, path)
+  return { ir: jsxToIR(ctx), ctx }
+}
+describe('import-scoped recognition for <Async> / <Region>', () => {
+  test('<Async> imported from @barefootjs/client lowers to IRAsync', () => {
+    const { ir: root, ctx } = ir(`
+      import { Async } from '@barefootjs/client'
+      export function Page() {
+        return <div><Async fallback={<p>Loading</p>}><Body /></Async></div>
+      }
+    `)
+    expect(ctx.errors.filter(e => e.severity === 'error')).toEqual([])
+    const div = root as IRElement
+    const async = div.children.find(c => c.type === 'async') as IRAsync
+    expect(async?.type).toBe('async')
+  })
+  test('<Region> imported from @barefootjs/client lowers to a region element', () => {
+    const { ir: root } = ir(`
+      import { Region } from '@barefootjs/client'
+      export function Shell({ children }) {
+        return <div><Region>{children}</Region></div>
+      }
+    `)
+    const div = root as IRElement
+    const region = div.children.find(
+      (c): c is IRElement => c.type === 'element' && c.regionId !== undefined,
+    )
+    expect(region).toBeDefined()
+  })
+  test('aliased import `Async as Boundary` recognises <Boundary> as the built-in', () => {
+    const { ir: root } = ir(`
+      import { Async as Boundary } from '@barefootjs/client'
+      export function Page() {
+        return <Boundary fallback={<p>Loading</p>}><Body /></Boundary>
+      }
+    `)
+    expect((root as IRAsync).type).toBe('async')
+  })
+  test("a user's own <Async> (imported elsewhere) is NOT lowered and emits no diagnostic", () => {
+    const { ir: root, ctx } = ir(`
+      import { Async } from './my-async'
+      export function Page() {
+        return <div><Async fallback={<p>x</p>}><Body /></Async></div>
+      }
+    `)
+    expect(ctx.errors.find(e => e.code === ErrorCodes.BUILTIN_REQUIRES_IMPORT)).toBeUndefined()
+    const div = root as IRElement
+    expect(div.children.some(c => c.type === 'async')).toBe(false)
+    const comp = div.children.find((c): c is IRComponent => c.type === 'component')
+    expect(comp?.name).toBe('Async')
+  })
+  test('a locally declared Async component is NOT treated as the built-in', () => {
+    const { ir: root, ctx } = ir(`
+      function Async(props) { return <section>{props.children}</section> }
+      export function Page() {
+        return <Async fallback={<p>x</p>}><Body /></Async>
+      }
+    `)
+    expect(ctx.errors.find(e => e.code === ErrorCodes.BUILTIN_REQUIRES_IMPORT)).toBeUndefined()
+    expect((root as IRElement).type).not.toBe('async')
+  })
+  test('bare <Async> with no import and no binding reports BF054', () => {
+    const { ctx } = ir(`
+      export function Page() {
+        return <Async fallback={<p>Loading</p>}><Body /></Async>
+      }
+    `)
+    const err = ctx.errors.find(e => e.code === ErrorCodes.BUILTIN_REQUIRES_IMPORT)
+    expect(err).toBeDefined()
+    expect(err?.severity).toBe('error')
+    expect(err?.message).toContain('@barefootjs/client')
+  })
+  test('a type-only import does NOT scope the built-in and does not suppress BF054', () => {
+    // `import type { Async }` brings no value binding into scope — the design
+    // is import-value-required, so <Async> must still raise BF054.
+    const { ir: root, ctx } = ir(`
+      import type { Async } from '@barefootjs/client'
+      export function Page() {
+        return <Async fallback={<p>Loading</p>}><Body /></Async>
+      }
+    `)
+    expect((root as IRElement).type).not.toBe('async')
+    expect(ctx.errors.find(e => e.code === ErrorCodes.BUILTIN_REQUIRES_IMPORT)).toBeDefined()
+  })
+  test('a per-specifier type-only import (`import { type Async }`) does NOT scope the built-in', () => {
+    const { ir: root, ctx } = ir(`
+      import { type Async } from '@barefootjs/client'
+      export function Page() {
+        return <Async fallback={<p>Loading</p>}><Body /></Async>
+      }
+    `)
+    expect((root as IRElement).type).not.toBe('async')
+    expect(ctx.errors.find(e => e.code === ErrorCodes.BUILTIN_REQUIRES_IMPORT)).toBeDefined()
+  })
+  test('a value specifier alongside a type-only one is still recognised (`import { type Async, Region }`)', () => {
+    const { ir: root } = ir(`
+      import { type Async, Region } from '@barefootjs/client'
+      export function Shell({ children }) {
+        return <div><Region>{children}</Region></div>
+      }
+    `)
+    const div = root as IRElement
+    expect(div.children.some(c => c.type === 'element' && c.regionId !== undefined)).toBe(true)
+  })
+  test('bare <Region /> with no import reports BF054', () => {
+    const { ctx } = ir(`
+      export function Shell() {
+        return <Region />
+      }
+    `)
+    expect(ctx.errors.find(e => e.code === ErrorCodes.BUILTIN_REQUIRES_IMPORT)).toBeDefined()
+  })
+})
+describe('stripClientBuiltinImports (emit-time elision)', () => {
+  const loc = { file: 'x.tsx', line: 1, column: 1 }
+  const imp = (source: string, names: string[]): ImportInfo => ({
+    source,
+    isTypeOnly: false,
+    loc,
+    specifiers: names.map(n => ({ name: n, alias: null, isDefault: false, isNamespace: false })),
+  })
+  test('drops the @barefootjs/client import when it only carried built-ins', () => {
+    expect(stripClientBuiltinImports([imp('@barefootjs/client', ['Async', 'Region'])])).toEqual([])
+  })
+  test('keeps non-built-in specifiers and drops the built-ins', () => {
+    const out = stripClientBuiltinImports([imp('@barefootjs/client', ['createSignal', 'Async'])])
+    expect(out).toHaveLength(1)
+    expect(out[0].specifiers.map(s => s.name)).toEqual(['createSignal'])
+  })
+  test('leaves imports from other sources untouched', () => {
+    const other = imp('./my-async', ['Async'])
+    expect(stripClientBuiltinImports([other])).toEqual([other])
+  })
+  test('does NOT strip type-only imports (never a runtime phantom)', () => {
+    const typeOnly: ImportInfo = { ...imp('@barefootjs/client', ['Async', 'Region']), isTypeOnly: true }
+    expect(stripClientBuiltinImports([typeOnly])).toEqual([typeOnly])
+  })
+  test('preserves a side-effect import of @barefootjs/client', () => {
+    const sideEffect = imp('@barefootjs/client', [])
+    expect(stripClientBuiltinImports([sideEffect])).toEqual([sideEffect])
+  })
+  test('does NOT strip a per-specifier type-only built-in, but strips the value one', () => {
+    const mixed: ImportInfo = {
+      source: '@barefootjs/client',
+      isTypeOnly: false,
+      loc,
+      specifiers: [
+        { name: 'Async', alias: null, isDefault: false, isNamespace: false, isTypeOnly: true },
+        { name: 'Region', alias: null, isDefault: false, isNamespace: false, isTypeOnly: false },
+      ],
+    }
+    const out = stripClientBuiltinImports([mixed])
+    expect(out).toHaveLength(1)
+    expect(out[0].specifiers.map(s => s.name)).toEqual(['Async'])
+    expect(out[0].specifiers[0].isTypeOnly).toBe(true)
+  })
+})

package/src/__tests__/ir-region.test.ts ADDED Viewed

@@ -0,0 +1,86 @@
+import { describe, test, expect } from 'bun:test'
+import { analyzeComponent } from '../analyzer'
+import { jsxToIR } from '../jsx-to-ir'
+import { compileJSX } from '../compiler'
+import { HonoAdapter } from '../../../../packages/adapter-hono/src/adapter/hono-adapter'
+import type { IRElement } from '../types'
+const LAYOUT = `
+  import { Region } from '@barefootjs/client'
+  export function Layout({ title, children }) {
+    return (
+      <div>
+        <h1>{title}</h1>
+        <Region>{children}</Region>
+      </div>
+    )
+  }
+`
+function regionEl(source: string, path: string): IRElement {
+  const ir = jsxToIR(analyzeComponent(source, path))
+  const root = ir as IRElement
+  const region = root.children.find(
+    (c): c is IRElement => c.type === 'element' && c.regionId !== undefined,
+  )
+  if (!region) throw new Error('no region element found')
+  return region
+}
+function markedTemplate(source: string, path: string): string {
+  const result = compileJSX(source, path, { adapter: new HonoAdapter() })
+  expect(result.errors).toHaveLength(0)
+  const marked = result.files.find(f => f.type === 'markedTemplate')
+  if (!marked) throw new Error('no markedTemplate emitted')
+  return marked.content
+}
+describe('<Region> page-lifecycle boundary', () => {
+  test('lowers <Region>{children}</Region> to a div carrying a regionId', () => {
+    const region = regionEl(LAYOUT, 'Layout.tsx')
+    expect(region.tag).toBe('div')
+    expect(region.regionId).toMatch(/^[0-9a-f]{8}:0$/)
+    // The children passed to the region are preserved inside it.
+    expect(region.children.length).toBeGreaterThan(0)
+  })
+  test('assigns sequential structural indices within a file', () => {
+    const source = `
+      import { Region } from '@barefootjs/client'
+      export function Split() {
+        return (
+          <div>
+            <Region><aside /></Region>
+            <Region><main /></Region>
+          </div>
+        )
+      }
+    `
+    const ir = jsxToIR(analyzeComponent(source, 'Split.tsx')) as IRElement
+    const ids = ir.children
+      .filter((c): c is IRElement => c.type === 'element' && c.regionId !== undefined)
+      .map(c => c.regionId)
+    expect(ids).toHaveLength(2)
+    expect(ids[0]).toMatch(/:0$/)
+    expect(ids[1]).toMatch(/:1$/)
+  })
+  test('Hono adapter emits bf-region on the boundary element', () => {
+    expect(markedTemplate(LAYOUT, 'Layout.tsx')).toMatch(/bf-region="[0-9a-f]{8}:0"/)
+  })
+  test('region id is deterministic across compiles (not per-run random)', () => {
+    // The load-bearing requirement: a layout compiled twice — as it would be
+    // when two different pages each compose it — must emit the *same* id, so
+    // the client router can match the same region across page documents.
+    const a = regionEl(LAYOUT, '/app/shell.tsx').regionId
+    const b = regionEl(LAYOUT, '/app/shell.tsx').regionId
+    expect(a).toBe(b)
+  })
+  test('region id differs across layout files (cross-file uniqueness)', () => {
+    const a = regionEl(LAYOUT, '/app/shell-a.tsx').regionId
+    const b = regionEl(LAYOUT, '/app/shell-b.tsx').regionId
+    expect(a).not.toBe(b)
+  })
+})

package/src/__tests__/profiler.test.ts CHANGED Viewed

@@ -9,6 +9,7 @@
 import { describe, test, expect } from 'bun:test'
 import {
+  PROFILE_SCHEMA_VERSION,
   buildStaticBudget,
   diffStaticBudget,
   formatStaticBudget,
@@ -179,6 +180,73 @@ describe('buildStaticBudget (SR5)', () => {
     expect(b.subscriptions).toBe(0)
     expect(b.crossComponentOnly).toBe(false)
   })
+  test('exposes the handlers --scenario auto would fire, name + loc (#1841 A1)', () => {
+    // Two handlers on distinct elements/events. The static list is the coverage
+    // gap an agent can read before any run.
+    const src = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function Form() {
+        const [q, setQ] = createSignal('')
+        return (
+          <div>
+            <input onInput={(e) => setQ(e.currentTarget.value)} />
+            <button onClick={() => setQ('')}>Clear</button>
+          </div>
+        )
+      }
+    `
+    const b = buildStaticBudget(src, 'Form.tsx', 'Form')
+    expect(b.handlers.length).toBe(2)
+    // `name` is `<event>@<slotId>` — the slotId joins to dynamic coverage.
+    expect(b.handlers.every(h => /^\w+@\w+$/.test(h.name))).toBe(true)
+    const events = b.handlers.map(h => h.name.split('@')[0]).sort()
+    expect(events).toEqual(['click', 'input'])
+    // Each handler carries a source location.
+    for (const h of b.handlers) {
+      expect(h.loc.file).toContain('Form.tsx')
+      expect(h.loc.line).toBeGreaterThan(0)
+    }
+  })
+  test('handlers is empty when the component binds none', () => {
+    const src = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function Display() {
+        const [n] = createSignal(0)
+        return <div>{n()}</div>
+      }
+    `
+    const b = buildStaticBudget(src, 'Display.tsx', 'Display')
+    expect(b.handlers).toEqual([])
+  })
+  test('renders a handlers section in text output when present, omits it otherwise', () => {
+    const withHandler = formatStaticBudget(buildStaticBudget(counterSource, 'Counter.tsx', 'Counter'))
+    expect(withHandler).toMatch(/handlers \(1\):/)
+    expect(withHandler).toMatch(/click@\w+\s+Counter\.tsx:\d+/)
+    const noHandler = `
+      'use client'
+      import { createSignal } from '@barefootjs/client'
+      export function Display() {
+        const [n] = createSignal(0)
+        return <div>{n()}</div>
+      }
+    `
+    expect(formatStaticBudget(buildStaticBudget(noHandler, 'Display.tsx', 'Display'))).not.toContain('handlers (')
+  })
+})
+describe('schemaVersion (#1841)', () => {
+  test('every JSON mode carries the schema version', () => {
+    const budget = buildStaticBudget(counterSource, 'Counter.tsx', 'Counter')
+    expect(budget.schemaVersion).toBe(PROFILE_SCHEMA_VERSION)
+    const diff = diffStaticBudget(budget, buildStaticBudget(memoChainSource, 'Calc.tsx', 'Calc'))
+    expect(diff.schemaVersion).toBe(PROFILE_SCHEMA_VERSION)
+  })
 })
 describe('diffStaticBudget (SR6)', () => {
@@ -345,6 +413,7 @@ describe('buildProfileReport (dynamic, SR1–SR4 + analyses)', () => {
     ]
     const r = buildProfileReport({ source: src, filePath: 'Calc.tsx', scenario: 'auto', events })
     expect(r.kind).toBe('profile')
+    expect(r.schemaVersion).toBe(PROFILE_SCHEMA_VERSION)
     expect(r.componentName).toBe('Calc')
     expect(r.turns).toBe(1)
     expect(r.hotSubscribers.subscribers[0].name).toBe('a')

package/src/__tests__/ssr-defaults.test.ts CHANGED Viewed

@@ -99,6 +99,31 @@ describe('extractSsrDefaults', () => {
     expect(defaults?.doubled).toEqual({ value: 10 })
   })
+  test('block-body memo with an early-return guard folds to the default-state branch (#1897)', () => {
+    // The data-table `sortedData` shape: a `/* @client */`-guarded sort
+    // whose early return yields the unsorted module-const array when the
+    // sort-key signal is at its initial (null) value. The SSR default is
+    // that early-return array, not `null` — the `if (!key)` guard is
+    // taken because `sortKey()` resolves to its seeded `null` initial.
+    const metadata = metadataFor(`
+      'use client'
+      import { createSignal, createMemo } from '@barefootjs/client'
+      const rows = [{ id: 'a' }, { id: 'b' }]
+      function Table() {
+        const [sortKey, setSortKey] = createSignal<string | null>(null)
+        const sorted = createMemo(() => {
+          const key = sortKey()
+          if (!key) return rows
+          return /* @client */ [...rows].sort((a, b) => a.id < b.id ? -1 : 1)
+        })
+        return <ul>{sorted().map(r => <li>{r.id}</li>)}</ul>
+      }
+    `)
+    const defaults = extractSsrDefaults(metadata)
+    expect(defaults?.sorted).toEqual({ value: [{ id: 'a' }, { id: 'b' }] })
+  })
   test('non-evaluable initials yield null (caller falls back at render time)', () => {
     const metadata = metadataFor(`
       'use client'

package/src/adapters/env-signal.ts ADDED Viewed

@@ -0,0 +1,75 @@
+// Shared recognition of the router v0.5 `searchParams()` environment signal
+// for the template-string adapters (Mojo / Xslate today; Go has its own
+// struct-field path). A request-scoped reactive env signal reads like an
+// ordinary signal getter, but its value is a URLSearchParams-like reader with
+// real methods (`.get(key)`) — not a hashref. The generic `member` lowering
+// would deref `.get` as a property access and drop the call + argument, so the
+// adapters special-case it to a real per-request reader method call. See #1922.
+import type { ParsedExpr } from '../expression-parser.ts'
+import type { IRMetadata } from '../types.ts'
+/**
+ * The local binding name(s) that `searchParams` from `@barefootjs/client` is
+ * imported under in this component — the same import the analyzer allow-lists
+ * (`CLIENT_EXPORTS`). Usually the single name `searchParams`, but an aliased
+ * import (`import { searchParams as sp }`) binds it to `sp`, and the template
+ * expression then reads `sp()` — so adapters must gate + match against the
+ * LOCAL name(s), not the literal `searchParams`. Empty when the env signal is
+ * not imported (the component keeps the generic signal lowering).
+ *
+ * `ImportSpecifier.name` is the exported name and `alias` the local rebinding
+ * (see `collectImport` in analyzer.ts), so the import is detected by `name ===
+ * 'searchParams'` and the local binding is `alias ?? name`. Namespace / default
+ * specifiers bind a different identifier and are excluded.
+ */
+export function searchParamsLocalNames(metadata: IRMetadata): Set<string> {
+  const names = new Set<string>()
+  for (const imp of metadata.imports) {
+    if (imp.source !== '@barefootjs/client' || imp.isTypeOnly) continue
+    for (const s of imp.specifiers) {
+      if (s.isTypeOnly || s.isNamespace || s.isDefault) continue
+      if (s.name === 'searchParams') names.add(s.alias ?? s.name)
+    }
+  }
+  return names
+}
+/**
+ * True when the component imports the `searchParams` env signal under any local
+ * name. Convenience for adapters/harnesses that only need to gate on presence
+ * (the lowering itself needs the {@link searchParamsLocalNames} set to match the
+ * actual binding in the expression).
+ */
+export function importsSearchParams(metadata: IRMetadata): boolean {
+  return searchParamsLocalNames(metadata).size > 0
+}
+/**
+ * Recognise a `<binding>().<method>(<args>)` env-signal method call from a
+ * `call` node's callee + args, where `<binding>` is one of the local names
+ * `searchParams` was imported under (`localNames`, from
+ * {@link searchParamsLocalNames}). Returns the method name and argument nodes
+ * when the receiver is the zero-arg env-signal getter, else null. The caller
+ * lowers the match to a real method call on its per-request reader object
+ * (`$searchParams->get('sort')` in Mojo, `$searchParams.get('sort')` in
+ * Xslate — the canonical `$searchParams` var regardless of the JS alias);
+ * without it the generic `member` lowering drops the call + arg.
+ */
+export function matchSearchParamsMethodCall(
+  callee: ParsedExpr,
+  args: ParsedExpr[],
+  localNames: ReadonlySet<string>,
+): { method: string; args: ParsedExpr[] } | null {
+  if (callee.kind !== 'member' || callee.computed) return null
+  const recv = callee.object
+  if (
+    recv.kind !== 'call' ||
+    recv.args.length !== 0 ||
+    recv.callee.kind !== 'identifier' ||
+    !localNames.has(recv.callee.name)
+  ) {
+    return null
+  }
+  return { method: callee.property, args }
+}

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

@@ -66,6 +66,7 @@ export type ArrayMethod =
   | 'toLowerCase'
   | 'toUpperCase'
   | 'trim'
+  | 'toFixed'
   | 'split'
   | 'startsWith'
   | 'endsWith'
@@ -115,6 +116,14 @@ export interface ParsedExprEmitter {
     computed: boolean,
     emit: (e: ParsedExpr) => string,
   ): string
+  // Element access with a non-literal index (`arr[index]`). The index
+  // is a full `ParsedExpr` (loop variable, arithmetic, etc.); the
+  // adapter picks array vs hash deref per target language. #1897.
+  indexAccess(
+    object: ParsedExpr,
+    index: ParsedExpr,
+    emit: (e: ParsedExpr) => string,
+  ): string
   binary(op: string, left: ParsedExpr, right: ParsedExpr, emit: (e: ParsedExpr) => string): string
   unary(op: string, argument: ParsedExpr, emit: (e: ParsedExpr) => string): string
   logical(
@@ -196,6 +205,8 @@ export function emitParsedExpr(expr: ParsedExpr, emitter: ParsedExprEmitter): st
       return emitter.call(expr.callee, expr.args, emit)
     case 'member':
       return emitter.member(expr.object, expr.property, expr.computed, emit)
+    case 'index-access':
+      return emitter.indexAccess(expr.object, expr.index, emit)
     case 'binary':
       return emitter.binary(expr.op, expr.left, expr.right, emit)
     case 'unary':

package/src/analyzer.ts CHANGED Viewed

@@ -1648,6 +1648,13 @@ const CLIENT_EXPORTS = new Set([
   'forwardProps', 'unwrap', '__slot',
   'createContext', 'useContext', 'provideContext',
   'createPortal', 'isSSRPortal', 'findSiblingSlot', 'cleanupPortalPlaceholder',
+  // Request-scoped environment signal (router v0.5) — a real user-facing
+  // reactive export the compiler lowers like any other `@barefootjs/client`
+  // signal read (SSR: a template binding; client: a `createEffect`).
+  'searchParams',
+  // Compile-away JSX built-ins (#1915) — importing them is what scopes the
+  // compiler's `<Async>` / `<Region>` recognition; the import is elided on emit.
+  'Async', 'Region',
 ])
 /**
@@ -1748,6 +1755,8 @@ function collectImport(node: ts.ImportDeclaration, ctx: AnalyzerContext): void {
             alias: element.propertyName ? element.name.text : null,
             isDefault: false,
             isNamespace: false,
+            // Per-specifier `import { type Foo }` — no value binding (#1915).
+            isTypeOnly: element.isTypeOnly,
           })
         }
       }