@barefootjs/xslate 0.14.0 → 0.15.0

package/src/adapter/xslate-adapter.ts

@@ -55,6 +55,8 @@ import {
   type AttrValueEmitter,
   isBooleanAttr,
   parseExpression,
+  exprToString,
+  parseProviderObjectLiteral,
   parseStyleObjectEntries,
   isSupported,
   identifierPath,
@@ -64,11 +66,14 @@ import {
   augmentInheritedPropAccesses,
   parseRecordIndexAccess,
   evalStringArrayJoin,
+  collectModuleStringConsts,
   extractArrowBodyExpression,
   collectContextConsumers,
   isLowerableObjectRestDestructure,
   type ContextConsumer,
-  extractSsrDefaults,
+  lookupStaticRecordLiteral,
+  searchParamsLocalNames,
+  matchSearchParamsMethodCall
 } from '@barefootjs/jsx'
 import { isAriaBooleanAttr, isBooleanResultExpr } from './boolean-result.ts'
 import ts from 'typescript'
@@ -81,7 +86,7 @@ import ts from 'typescript'
  */
 type XslateRenderCtx = Record<string, never>
 import type { ParsedExpr, ParsedStatement, SortComparator, ReduceOp, FlatDepth, FlatMapOp, TemplatePart } from '@barefootjs/jsx'
-import { BF_SLOT, BF_COND } from '@barefootjs/shared'
+import { BF_SLOT, BF_COND, BF_REGION } from '@barefootjs/shared'
 
 interface PrimitiveSpec {
   arity: number
@@ -223,6 +228,7 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
    */
   private propsObjectName: string | null = null
   private propsParams: { name: string }[] = []
+  private booleanTypedProps: Set<string> = new Set()
   /**
    * Names (signal getters + props) whose value is a string, so `===`/`!==`
    * against them lowers to Perl `eq`/`ne` rather than numeric `==`/`!=`.
@@ -241,6 +247,16 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
    */
   private moduleStringConsts: Map<string, string> = new Map()
 
+  /**
+   * (#1922) Local binding names the request-scoped `searchParams()` env signal
+   * is imported under (handles `import { searchParams as sp }`). When non-empty
+   * the emitter lowers a `<binding>().get(k)` call to a real method call on the
+   * per-request `$searchParams` reader (`$searchParams.get('sort')`) instead of
+   * the generic dot deref. Set at `generate()` entry from `ir.metadata.imports`;
+   * read by the top-level ParsedExpr emitter.
+   */
+  _searchParamsLocals: Set<string> = new Set()
+
   /**
    * Local + module constants from the IR, used by the conditional-spread and
    * `Record<staticKeys, scalar>[propKey]` lowering paths (#textarea / #checkbox).
@@ -274,6 +290,15 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
     // shared helper, before deriving `nullableOptionalProps` below.
     augmentInheritedPropAccesses(ir)
     this.propsParams = ir.metadata.propsParams.map(p => ({ name: p.name }))
+    // Props whose declared TS type is boolean — a bare binding of one
+    // (`data-active={props.isActive}`) must stringify as JS
+    // `String(boolean)` ("true"/"false"), not Perl's native `1`/`''`
+    // (#1897, pagination's data-active).
+    this.booleanTypedProps = new Set(
+      ir.metadata.propsParams
+        .filter(prop => prop.type?.primitive === 'boolean' || prop.type?.raw === 'boolean')
+        .map(prop => prop.name),
+    )
     this.localConstants = ir.metadata.localConstants ?? []
     // Bare references to optional, no-default, non-primitive props (e.g.
     // textarea's `rows`) are `undef` when omitted → `defined`-guarded in
@@ -302,6 +327,7 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
       if (isStringTypeInfo(p.type)) this.stringValueNames.add(p.name)
     }
     this.moduleStringConsts = collectModuleStringConsts(ir.metadata.localConstants)
+    this._searchParamsLocals = searchParamsLocalNames(ir.metadata)
     this.errors = []
     this.childrenCaptureCounter = 0
 
@@ -473,12 +499,48 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
         ? `'${v.value.replace(/[\\']/g, m => `\\${m}`)}'`
         : String(v.value)
     }
-    if (v.kind === 'expression') return this.convertExpressionToKolon(v.expr)
+    if (v.kind === 'expression') {
+      const hashref = this.providerObjectLiteralKolon(v.expr)
+      if (hashref !== null) return hashref
+      return this.convertExpressionToKolon(v.expr)
+    }
     if (v.kind === 'template') return this.convertTemplateLiteralPartsToKolon(v.parts)
     // Out-of-shape value (spread / jsx-children) — nil; consumer defaults.
     return 'nil'
   }
 
+  /**
+   * Lower an object-literal provider value (`value={{ open: () => props.open
+   * ?? false, onOpenChange: … }}`) to a Kolon hashref literal (#1897). The
+   * SSR lowering is a per-member snapshot of what a consumer would READ
+   * during the same render:
+   *
+   * - zero-param expression-body arrows are getters — lower the body (the
+   *   value is fixed for the render, so the call-time indirection drops out)
+   * - `on[A-Z]`-named members and function-shaped values are client-only
+   *   behavior SSR never invokes — lower to `nil`
+   * - anything else lowers through the normal expression pipeline (so an
+   *   unsupported getter body still refuses loudly with BF101)
+   *
+   * Keys keep their JS names verbatim so a consumer-side `ctx.open` access
+   * maps onto the same key. Returns `null` when the expression is not a
+   * plain object literal (spread / computed key) — the caller falls back to
+   * the whole-expression path, which refuses those shapes with BF101.
+   */
+  private providerObjectLiteralKolon(expr: string): string | null {
+    const members = parseProviderObjectLiteral(expr.trim())
+    if (members === null) return null
+    const entries = members.map(m => {
+      // String-literal JS keys can carry `'` / `\` — escape for the
+      // single-quoted Kolon key string.
+      const key = `'${m.name.replace(/[\\']/g, c => `\\${c}`)}'`
+      if (m.kind === 'function' || /^on[A-Z]/.test(m.name)) return `${key} => nil`
+      const src = m.kind === 'getter' ? m.body : m.expr
+      return `${key} => ${this.convertExpressionToKolon(src)}`
+    })
+    return `{ ${entries.join(', ')} }`
+  }
+
   /** Kolon literal for a context-consumer's `createContext` default. */
   private contextDefaultKolon(c: ContextConsumer): string {
     const d = c.defaultValue
@@ -518,7 +580,6 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
     const memos = ir.metadata.memos ?? []
     const signals = ir.metadata.signals ?? []
     if (memos.length === 0 && signals.length === 0) return ''
-    const ssrDefaults = extractSsrDefaults(ir.metadata) ?? {}
     // Props seed first; each signal/memo adds its own name as it lands.
     const available = new Set<string>(ir.metadata.propsParams.map(p => p.name))
     const lines: string[] = []
@@ -542,16 +603,22 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
     }
 
     for (const memo of memos) {
-      const def = ssrDefaults[memo.name]
-      const isNull = !def || (typeof def === 'object' && 'value' in def && def.value === null)
-      if (!isNull) {
-        available.add(memo.name)
-        continue
-      }
+      // Seed every memo whose body lowers cleanly — not just the ones whose
+      // static SSR default is null. A statically-foldable prop-derived memo
+      // (`createMemo(() => props.disabled ?? false)` → default `false`)
+      // still depends on the per-call prop: the static stash seed bakes in
+      // the absent-prop fold, so a caller passing `disabled => 1` would
+      // render the default branch (#1897, select's disabled item). The
+      // in-template recomputation reads the prop lexical already in scope;
+      // block-bodied arrows / out-of-scope references fall back to the
+      // static ssr-defaults seed. Same self-reference guard as the signal
+      // loop above — Kolon's `my` shadows the render var on the RHS.
       const body = extractArrowBodyExpression(memo.computation)
-      if (body === null) continue
-      const kolon = this.tryLowerToKolon(body, available)
-      if (kolon !== null) lines.push(`: my $${memo.name} = ${kolon};`)
+      if (body !== null) {
+        const kolon = this.tryLowerToKolon(body, available)
+        const refsSelf = kolon !== null && new RegExp(`\\$${memo.name}\\b`).test(kolon)
+        if (kolon !== null && !refsSelf) lines.push(`: my $${memo.name} = ${kolon};`)
+      }
       available.add(memo.name)
     }
     return lines.length > 0 ? lines.join('\n') + '\n' : ''
@@ -600,6 +667,12 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
     if (element.slotId) {
       hydrationAttrs += ` ${this.renderSlotMarker(element.slotId)}`
     }
+    // Page-lifecycle boundary lowered from `<Region>` (spec/router.md). The id
+    // is a deterministic static string (`<file scope>:<index>`), so it emits as
+    // a plain literal attribute — no Xslate template tag.
+    if (element.regionId) {
+      hydrationAttrs += ` ${BF_REGION}="${element.regionId}"`
+    }
 
     const voidElements = [
       'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
@@ -959,8 +1032,9 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
   renderComponent(comp: IRComponent): string {
     const propParts: string[] = []
     for (const p of comp.props) {
-      // Skip callback props (onXxx) — event handlers are client-only for SSR.
-      if (p.name.match(/^on[A-Z]/) && p.value.kind === 'expression') continue
+      // Skip callback props (onXxx) and `ref` — both are client-only for
+      // SSR (Hono renders neither; the client JS wires them at hydration).
+      if ((p.name.match(/^on[A-Z]/) || p.name === 'ref') && p.value.kind === 'expression') continue
       // Spread props: enumerate the analyzer's props params into hashref
       // entries (the propsObject case) — Kolon can't flatten a hashref into
       // the entry list. Other spread shapes are refused with BF101.
@@ -1006,7 +1080,10 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
       // children HTML; the macro call result is passed as the `children` entry
       // of the render_child hashref. `render_child` materializes a CODE-ref
       // children value through the backend before handing it to the child.
+      const prevInLoop = this.inLoop
+      this.inLoop = false
       const childrenBody = this.renderChildren(effectiveChildren)
+      this.inLoop = prevInLoop
       const macroName = `bf_children_${comp.slotId ?? 'c' + this.childrenCaptureCounter++}`
       const childrenEntry = `children => ${macroName}()`
       const allParts = [...propParts, childrenEntry]
@@ -1019,6 +1096,10 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
 
   private childrenCaptureCounter = 0
 
+  /** Uniquifies the `presenceOrUndefined` temp binding (`$bf_puN`) so two
+   *  presence-folded attrs in one template don't collide. */
+  private presenceVarCounter = 0
+
   private toTemplateName(componentName: string): string {
     // Convert PascalCase to snake_case for template naming.
     return componentName
@@ -1129,21 +1210,51 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
       ) {
         const perl = this.convertExpressionToKolon(value.expr)
         const body =
-          isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name)
+          isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name) || this.isBooleanTypedPropRef(value.expr)
             ? `${name}="<: $bf.bool_str(${perl}) :>"`
             : `${name}="<: ${perl} :>"`
         // Kolon `:` line directives must each stand alone on their own line, so
         // wrap in newlines (`normalizeHTML` collapses the surrounding space).
         return `\n: if (defined ${perl}) {\n${body}\n: }\n`
       }
-      if (isBooleanAttr(name) || value.presenceOrUndefined) {
+      if (isBooleanAttr(name)) {
         // Boolean attributes: render conditionally (present or absent).
         return `<: ${this.convertExpressionToKolon(value.expr)} ? '${name}' : '' :>`
       }
+      if (value.presenceOrUndefined) {
+        // `attr={expr || undefined}` on a NON-boolean attribute: Hono
+        // renders the attr with its stringified value when truthy and
+        // omits it otherwise (`aria-disabled={isDisabled() || undefined}`
+        // → `aria-disabled="true"`), so bare presence would diverge.
+        // Route through `bool_str` when the name/shape witnesses a
+        // boolean value, same as the unconditional path below (#1897).
+        // Bind to a temp first so the expression evaluates once, not in
+        // both the guard and the value.
+        const perl = this.convertExpressionToKolon(value.expr)
+        const tmp = `$bf_pu${this.presenceVarCounter++}`
+        const body =
+          isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name) || this.isBooleanTypedPropRef(value.expr)
+            ? `${name}="<: $bf.bool_str(${tmp}) :>"`
+            : `${name}="<: ${tmp} :>"`
+        return `\n: my ${tmp} = ${perl};\n: if (${tmp}) {\n${body}\n: }\n`
+      }
+      // `attr={cond ? value : undefined}` OMITS the attribute on the
+      // falsy branch (Hono drops undefined-valued attributes) — wrap the
+      // whole attribute in the condition instead of rendering `attr=""`
+      // (#1897, pagination's `aria-current={props.isActive ? 'page' :
+      // undefined}`). Same parity rule the Go adapter applies.
+      {
+        const m = this.parseUndefinedAlternateTernary(value.expr)
+        if (m) {
+          const cond = this.convertExpressionToKolon(m.condition)
+          const val = this.convertExpressionToKolon(m.consequent)
+          return `\n: if (${cond}) {\n${name}="<: ${val} :>"\n: }\n`
+        }
+      }
       // Boolean-result handling: route boolean-shaped values through
       // `$bf.bool_str` so the wire bytes match JS `String(boolean)`.
       const perl = this.convertExpressionToKolon(value.expr)
-      if (isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name)) {
+      if (isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name) || this.isBooleanTypedPropRef(value.expr)) {
         return `${name}="<: $bf.bool_str(${perl}) :>"`
       }
       return `${name}="<: ${perl} :>"`
@@ -1528,6 +1639,31 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
         return n
       })()
       const indexed = this.recordIndexAccessToKolon(initNode)
+      if (
+        indexed === null &&
+        ts.isElementAccessExpression(initNode) &&
+        initNode.argumentExpression &&
+        !ts.isNumericLiteral(initNode.argumentExpression) &&
+        !ts.isStringLiteral(initNode.argumentExpression)
+      ) {
+        // Variable-index record access (`sizeMap[size]`) the static-inline
+        // path couldn't resolve (non-scalar value / non-const receiver).
+        // Since #1897 made variable indices parseable (`index-access`),
+        // the generic value lowering would emit `$sizeMap[$size]` against
+        // an UNBOUND module const instead of refusing — record BF101 and
+        // bail so the spread surfaces the out-of-shape diagnostic,
+        // matching pre-#1897 behaviour. (Mirrors the Mojo adapter.)
+        this.errors.push({
+          code: 'BF101',
+          severity: 'error',
+          message: `Spread object value '${initNode.getText(sf)}' indexes a record map whose values aren't scalar literals — it can't lower to an inline Kolon hashref.`,
+          loc: { file: this.componentName + '.tsx', start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+          suggestion: {
+            message: 'Index a record whose values are number/string literals, or move the spread into a `\'use client\'` component so hydration computes it.',
+          },
+        })
+        return null
+      }
       const valPerl =
         indexed !== null
           ? indexed
@@ -1608,6 +1744,76 @@ export class XslateAdapter extends BaseAdapter implements IRNodeEmitter<XslateRe
    * normal `$name` stash lowering). Loop-bound names shadow module consts, so
    * never inline inside a loop body. Returns `'<escaped>'`.
    */
+  /**
+   * Resolve `IDENT.key` over a module object-literal const to its Kolon
+   * literal (`variantClasses.ghost` in a class template literal —
+   * #1897). Same compile-time inlining family as
+   * `_resolveModuleStringConst`; returns `null` for any non-static shape.
+   */
+  /**
+   * Whether `expr` is a bare reference to a boolean-TYPED prop
+   * (`props.isActive` / destructured `isActive`) — used to route the
+   * binding through `bool_str` even though the expression itself is
+   * structurally opaque (#1897).
+   */
+  /**
+   * Parse `cond ? value : undefined` (or `: null`), returning the
+   * condition/consequent source spans, else `null`. Used for the
+   * attribute-omission rule (#1897).
+   */
+  parseUndefinedAlternateTernary(
+    expr: string,
+  ): { condition: string; consequent: string } | null {
+    const parsed = parseExpression(expr.trim())
+    if (parsed?.kind !== 'conditional') return null
+    const alt = parsed.alternate
+    const isUndef =
+      (alt.kind === 'identifier' && (alt.name === 'undefined' || alt.name === 'null')) ||
+      (alt.kind === 'literal' && (alt.value === null || alt.value === undefined))
+    if (!isUndef) return null
+    // Serialise the parsed sub-expressions back to JS source rather than
+    // slicing `expr` text — `indexOf('?')` / `lastIndexOf(':')` would
+    // mis-split when the consequent itself contains `?` / `:` inside a
+    // string or nested ternary (`cond ? 'a:b' : undefined`).
+    return {
+      condition: exprToString(parsed.test),
+      consequent: exprToString(parsed.consequent),
+    }
+  }
+
+  isBooleanTypedPropRef(expr: string): boolean {
+    let bare = expr.trim()
+    if (this.propsObjectName && bare.startsWith(`${this.propsObjectName}.`)) {
+      bare = bare.slice(this.propsObjectName.length + 1)
+    }
+    if (!/^[A-Za-z_$][\w$]*$/.test(bare)) return false
+    return this.booleanTypedProps.has(bare)
+  }
+
+  /**
+   * Inline a const (any scope) whose initializer is a pure numeric or
+   * single-quoted string literal (`const totalPages = 5`, #1897
+   * pagination) — function-scope consts never reach the per-render
+   * stash, so a bare `$totalPages` renders empty.
+   */
+  _resolveLiteralConst(name: string): string | null {
+    const c = (this.localConstants ?? []).find(lc => lc.name === name)
+    if (c?.value === undefined) return null
+    const v = c.value.trim()
+    if (/^-?\d+(\.\d+)?$/.test(v)) return v
+    const strLit = /^'([^'\\]*)'$/.exec(v) ?? /^"([^"\\]*)"$/.exec(v)
+    if (strLit) return `'${strLit[1].replace(/[\\']/g, m => `\\${m}`)}'`
+    return null
+  }
+
+  _resolveStaticRecordLiteral(objectName: string, key: string): string | null {
+    const hit = lookupStaticRecordLiteral(objectName, key, this.localConstants)
+    if (!hit) return null
+    return hit.kind === 'number'
+      ? hit.text
+      : `'${hit.text.replace(/[\\']/g, m => `\\${m}`)}'`
+  }
+
   _resolveModuleStringConst(name: string): string | null {
     // A loop body may bind `my $<param>` that shadows a module const of the
     // same name; never inline inside one (conservative — drop to `$name`).
@@ -1721,6 +1927,13 @@ function renderArrayMethod(
       const recv = emit(object)
       return `$bf.trim(${recv})`
     }
+    case 'toFixed': {
+      // `.toFixed(digits?)` — `$bf.to_fixed` mirrors JS rounding +
+      // zero-padding (default 0 digits). #1897.
+      const recv = emit(object)
+      const digits = args.length >= 1 ? emit(args[0]) : '0'
+      return `$bf.to_fixed(${recv}, ${digits})`
+    }
     case 'split': {
       const recv = emit(object)
       if (args.length === 0) {
@@ -1881,21 +2094,6 @@ function unescapeStringLiteralBody(s: string): string {
   })
 }
 
-/**
- * Build the module pure-string-const map from the IR's localConstants. A const
- * qualifies only when module-scope (`isModule`) and its initializer parses to a
- * single pure string literal.
- */
-function collectModuleStringConsts(constants: IRMetadata['localConstants'] | undefined): Map<string, string> {
-  const map = new Map<string, string>()
-  for (const c of constants ?? []) {
-    if (!c.isModule) continue
-    if (c.value === undefined) continue
-    const literal = parsePureStringLiteral(c.value)
-    if (literal !== null) map.set(c.name, literal)
-  }
-  return map
-}
 
 /** True when `type` is the `string` primitive. */
 function isStringTypeInfo(type: TypeInfo | undefined): boolean {
@@ -1969,6 +2167,13 @@ class XslateFilterEmitter implements ParsedExprEmitter {
     return `${emit(object)}.${property}`
   }
 
+  indexAccess(object: ParsedExpr, index: ParsedExpr, emit: (e: ParsedExpr) => string): string {
+    // Kolon's `[]` postfix is polymorphic (array index or hash key),
+    // mirroring JS — no array/hash split is needed (unlike Perl's
+    // `->[]` vs `->{}`). #1897 (data-table's `selected()[index]`).
+    return `${emit(object)}[${emit(index)}]`
+  }
+
   call(callee: ParsedExpr, args: ParsedExpr[], emit: (e: ParsedExpr) => string): string {
     // Signal getter calls: filter() → $filter
     if (callee.kind === 'identifier' && args.length === 0) {
@@ -2088,10 +2293,17 @@ class XslateTopLevelEmitter implements ParsedExprEmitter {
   constructor(private readonly adapter: XslateAdapter) {}
 
   identifier(name: string): string {
+    // `undefined` / `null` nested inside a larger expression tree —
+    // Kolon `nil` (#1897).
+    if (name === 'undefined' || name === 'null') return 'nil'
     // Inline a module-scope pure-string const (`const x = 'literal'`) — it
     // never reaches the per-render stash, so a bare `$x` would render empty.
     const inlined = this.adapter._resolveModuleStringConst(name)
     if (inlined !== null) return inlined
+    // Same for a literal const of any scope (`const totalPages = 5`,
+    // #1897 pagination's `Page {currentPage()} of {totalPages}`).
+    const literalConst = this.adapter._resolveLiteralConst(name)
+    if (literalConst !== null) return literalConst
     return `$${name}`
   }
 
@@ -2108,6 +2320,14 @@ class XslateTopLevelEmitter implements ParsedExprEmitter {
     if (object.kind === 'identifier' && object.name === 'props') {
       return `$${property}`
     }
+    // Static property access on a module object-literal const
+    // (`variantClasses.ghost`, #1897) resolves at compile time — the
+    // generic dot lowering below would reference a Kolon var that
+    // doesn't exist server-side and silently render ''.
+    if (object.kind === 'identifier') {
+      const staticValue = this.adapter._resolveStaticRecordLiteral(object.name, property)
+      if (staticValue !== null) return staticValue
+    }
     const obj = emit(object)
     // `.length` → `$bf.length` (array count or string char count, JS-compat);
     // Kolon's builtin `.size()` is array-only and faults on a string.
@@ -2116,11 +2336,27 @@ class XslateTopLevelEmitter implements ParsedExprEmitter {
     return `${obj}.${property}`
   }
 
+  indexAccess(object: ParsedExpr, index: ParsedExpr, emit: (e: ParsedExpr) => string): string {
+    // Kolon's `[]` postfix is polymorphic (array index or hash key),
+    // mirroring JS. #1897 (data-table's `selected()[index]`).
+    return `${emit(object)}[${emit(index)}]`
+  }
+
   call(callee: ParsedExpr, args: ParsedExpr[], emit: (e: ParsedExpr) => string): string {
     // Signal getter: count() → $count
     if (callee.kind === 'identifier' && args.length === 0) {
       return `$${callee.name}`
     }
+    // Env-signal method call (#1922): `searchParams().get('sort')` is a real
+    // method call on the per-request `$searchParams` reader object, not the
+    // generic dot deref `member` would emit (`$searchParams.get`, which drops
+    // the arg). Matches the local import binding (incl. an alias).
+    if (this.adapter._searchParamsLocals.size > 0) {
+      const sp = matchSearchParamsMethodCall(callee, args, this.adapter._searchParamsLocals)
+      if (sp) {
+        return `$searchParams.${sp.method}(${sp.args.map(emit).join(', ')})`
+      }
+    }
     // Identifier-path templatePrimitive: `JSON.stringify(x)` / `Math.floor(x)`
     // → `$bf.json($x)` / `$bf.floor($x)`. Args render recursively through this
     // same emitter. A wrong-arity call records BF101 and returns `''`.

package/src/test-render.ts

@@ -17,7 +17,7 @@
  * than the Mojo harness's literal `test_<sN>`.
  */
 
-import { compileJSX, extractSsrDefaults } from '@barefootjs/jsx'
+import { compileJSX, extractSsrDefaults, importsSearchParams } from '@barefootjs/jsx'
 import type { ComponentIR } from '@barefootjs/jsx'
 import { mkdir, rm } from 'node:fs/promises'
 import { resolve } from 'node:path'
@@ -358,12 +358,29 @@ function buildChildRenderers(
     lines.push(`{`)
     lines.push(`  my $defaults = ${defaultsPerl};`)
     lines.push(`  $bf->register_child_renderer('${snakeName}', sub {`)
-    lines.push(`    my ($child_props) = @_;`)
+    // `$caller_bf` is the instance whose template invoked render_child
+    // (#1897) — nested children chain their scope/slot identity off it.
+    lines.push(`    my ($child_props, $caller_bf) = @_;`)
+    lines.push(`    my $host_scope = (defined $caller_bf ? $caller_bf->_scope_id : $bf->_scope_id);`)
     // A child that destructures a rest bag references `$<rest>` in its
     // template; seed it with an empty hashref when the caller didn't pass
     // one so Kolon's var lookup doesn't fault.
     if (restPropsName) {
       lines.push(`    $child_props->{${restPropsName}} = {} unless defined $child_props->{${restPropsName}};`)
+      // (#1897) Route non-param props into the rest bag, mirroring the
+      // production runtime's `_derive_stash_from_defaults` isRestProps
+      // branch and JSX rest semantics: a caller prop the child didn't
+      // destructure (`href` on PaginationPrevious's `{...props}` anchor)
+      // belongs in the bag, not as a top-level stash var the template
+      // never reads.
+      const paramNames = (childIR.metadata.propsParams ?? []).map(p => p.name)
+      const keep = JSON.stringify([...new Set([...paramNames, restPropsName, 'children', 'key', '_bf_slot'])])
+      lines.push(`    {`)
+      lines.push(`      my %keep = map { $_ => 1 } @{ ${perlArrayLiteral(keep)} };`)
+      lines.push(`      for my $k (grep { !$keep{$_} } keys %$child_props) {`)
+      lines.push(`        $child_props->{${restPropsName}}{$k} = delete $child_props->{$k};`)
+      lines.push(`      }`)
+      lines.push(`    }`)
     }
     lines.push(`    my $slot_id = delete $child_props->{_bf_slot};`)
     lines.push(`    my $child_bf = BarefootJS->new(undef, { backend => $backend });`)
@@ -374,9 +391,15 @@ function buildChildRenderers(
     // A loop child (no slot) gets a fresh `<ComponentName>_<rand>` id per
     // iteration — the PascalCase name is what `normalizeHTML` canonicalises to
     // `<ComponentName>_*`; a slotted child derives from the parent scope.
-    lines.push(`    $child_bf->_scope_id($slot_id ? '${rootChildScopePrefix(snakeName)}' . '_' . $slot_id : '${componentName}_' . substr(rand() =~ s/^0\\.//r, 0, 6));`)
+    lines.push(`    $child_bf->_scope_id($slot_id ? $host_scope . '_' . $slot_id : '${componentName}_' . substr(rand() =~ s/^0\\.//r, 0, 6));`)
     lines.push(`    $child_bf->_is_child(1);`)
-    lines.push(`    if ($slot_id) { $child_bf->_bf_parent('${rootChildScopePrefix(snakeName)}'); $child_bf->_bf_mount($slot_id); }`)
+    lines.push(`    if ($slot_id) { $child_bf->_bf_parent($host_scope); $child_bf->_bf_mount($slot_id); }`)
+    // (#1897) A child template may itself call `$bf.render_child(...)`
+    // (AccordionTrigger renders ChevronDownIcon) — inside that template
+    // `$bf` is THIS fresh child instance, whose renderer registry starts
+    // empty, so the nested call silently rendered ''. Share the parent's
+    // registry so nested child renders resolve.
+    lines.push(`    $child_bf->_child_renderers($bf->_child_renderers);`)
     lines.push(`    $child_bf->_scripts($bf->_scripts);`)
     lines.push(`    $child_bf->_script_seen($bf->_script_seen);`)
     // Seed template vars: static ssrDefaults first, caller's props win.
@@ -392,21 +415,12 @@ function buildChildRenderers(
   return lines.join('\n')
 }
 
-/**
- * The parent scope prefix child scope ids derive from. The harness pins
- * the root scope id to `test` (or `__instanceId`); children read the live
- * parent scope at render time, but the test renderer doesn't have the
- * parent `$bf` in lexical scope inside `buildChildRenderers`, so we use
- * the same `$bf->_scope_id` value the script set. Emitted as the literal
- * `$bf->_scope_id` lookup so an explicit `__instanceId` still flows
- * through.
- */
-function rootChildScopePrefix(_snakeName: string): string {
-  // Resolve the parent scope dynamically in Perl rather than baking the
-  // literal here — keeps the child id correct under an explicit
-  // __instanceId. The single quotes in the caller string-concat are
-  // closed around this Perl fragment.
-  return `' . $bf->_scope_id . '`
+
+
+/** Render a JSON string-array as a Perl arrayref literal (['a','b']). */
+function perlArrayLiteral(jsonArray: string): string {
+  const names = JSON.parse(jsonArray) as string[]
+  return `[${names.map(n => `'${n.replace(/[\\']/g, m => `\\${m}`)}'`).join(', ')}]`
 }
 
 /** Serialise an ssrDefaults map to a Perl hashref literal. */
@@ -517,6 +531,16 @@ function buildPerlProps(
     entries.push(`${memo.name} => ${toPerlLiteral(value ?? 0)}`)
   }
 
+  // (#1922) Request-scoped `searchParams()`: bind `$searchParams` to an
+  // empty-query reader via the lazy-loading factory (so the render script
+  // needn't `use BarefootJS::SearchParams`). The conformance harness issues no
+  // query string (the production Xslate integration builds this from the
+  // request's query), so `.get(k)` resolves to nil and the author's
+  // `?? default` renders. Only when the component imports `searchParams`.
+  if (importsSearchParams(ir.metadata)) {
+    entries.push(`searchParams => BarefootJS->search_params('')`)
+  }
+
   return `{${entries.join(', ')}}`
 }