@barefootjs/jsx 0.34.0 → 0.35.1

package/src/jsx-to-ir.ts

@@ -18,6 +18,7 @@ import {
   type IRIfStatement,
   type IRProvider,
   type IRAttribute,
+  type ExpressionAttr,
   type IREvent,
   type IRProp,
   type AttrValue,
@@ -44,7 +45,7 @@ import type { IRLoopSort, FunctionInfo, ConstantInfo } from './types.ts'
 import { formatParamWithType } from './module-exports.ts'
 import { createError, ErrorCodes, internalInvariant } from './errors.ts'
 import { CLIENT_BUILTIN_SOURCE, isClientBuiltinName, type ClientBuiltinTag } from './builtins.ts'
-import { containsReactiveExpression } from './reactivity-checker.ts'
+import { containsReactiveExpression, collectReactiveBrandLeaves } from './reactivity-checker.ts'
 import {
   rewriteBarePropRefs as rewriteBarePropRefsCore,
   collectAstPropRefs,
@@ -606,12 +607,14 @@ function collectBranchLocalPropRefsViaSubstitution(
   let acc: Set<string> | undefined
   function visit(n: ts.Node, parent?: ts.Node) {
     if (ts.isIdentifier(n) && propDepsMap!.has(n.text)) {
-      // Same skip rules as `collectAstPropRefs` — only value
-      // positions count, not object keys / property-access names.
+      // Same skip rules as `collectAstPropRefs` — only value positions
+      // count, not object keys / property-access names. A shorthand
+      // property (`{ page }`) IS a value reference (#2828) — its name
+      // is simultaneously the key and the value — so it participates
+      // here too, same as `collectAstPropRefs`.
       const isObjectKey = parent && ts.isPropertyAssignment(parent) && parent.name === n
-      const isShorthand = parent && ts.isShorthandPropertyAssignment(parent) && parent.name === n
       const isAccessName = parent && ts.isPropertyAccessExpression(parent) && parent.name === n
-      if (!isObjectKey && !isShorthand && !isAccessName) {
+      if (!isObjectKey && !isAccessName) {
         const deps = propDepsMap!.get(n.text)
         if (deps && deps.size > 0) {
           if (!acc) acc = new Set()
@@ -1484,15 +1487,13 @@ function lowerFormControlValueSsr(
 
   if (tagName === 'textarea') {
     if (children.length > 0) return
+    // A plain text child: SSR engines escape text children natively, and
+    // the client builders escape every child-position value by default
+    // (`ir-to-client-js/safe-html.ts`, #2795) — nothing to mark here.
     children.push({
       type: 'expression',
       expr,
-      // Escaped for client string-building; `expr` stays raw since SSR
-      // engines escape text children natively.
-      templateExpr: `escapeText(${templateExpr ?? expr})`,
-      // Init-scope builders can't just swap in `templateExpr` (its `_p.`
-      // binding differs) — see `escapeInClientTemplate`'s docstring.
-      escapeInClientTemplate: true,
+      templateExpr,
       typeInfo: null,
       reactive: false,
       slotId: null,
@@ -1502,7 +1503,7 @@ function lowerFormControlValueSsr(
     return
   }
 
-  const selectedForLiteral = (optValue: string): AttrValue =>
+  const selectedForLiteral = (optValue: string): ExpressionAttr =>
     AttrValueOf.expression(
       `(${expr}) === ${JSON.stringify(optValue)}`,
       templateExpr !== undefined
@@ -1519,35 +1520,129 @@ function lowerFormControlValueSsr(
   // `classifyLazyBinding` already know how to place into both `applyItem`
   // (row changed) and `applyOuter` (controlled value changed) — no new loop
   // machinery, just one more per-row reactive attribute (#2466).
-  const selectedForExpr = (optExpr: string, optTemplateExpr: string | undefined): AttrValue =>
+  const selectedForExpr = (optExpr: string, optTemplateExpr: string | undefined): ExpressionAttr =>
     AttrValueOf.expression(
       `(${expr}) === (${optExpr})`,
       templateExpr !== undefined || optTemplateExpr !== undefined
         ? { templateExpr: `(${templateExpr ?? expr}) === (${optTemplateExpr ?? optExpr})` }
         : undefined,
     )
+  // #2758: a bound value outside the option set makes SSR and hydration
+  // disagree about what "no match" means. SSR (below) never marks any
+  // `<option>` `selected`, so the browser falls back to its own default —
+  // the FIRST option. Hydration's controlled-value effect then assigns
+  // `select.value` directly (`emitValueUpdateStatements` in
+  // `ir-to-client-js/emit-reactive.ts`), and a value matching no option
+  // yields `selectedIndex = -1` (nothing selected). So the page renders
+  // showing the first option, and the moment hydration runs the selection
+  // visibly disappears.
+  //
+  // Resolution: treat the client's reading as correct ("no match" means no
+  // selection) and make SSR able to express it. When every `<option>` here
+  // is statically enumerable (no `.map()` loop, no conditional/component/
+  // slot child, no author-supplied `selected`), collect each option's match
+  // condition and, for a single-selection `<select>` (not `multiple`, not
+  // `size` > 1 — a list-box already shows no implicit default, so SSR and
+  // hydration already agree there), inject a hidden `disabled` placeholder
+  // option whose own `selected` is the negation of every real option's
+  // condition ORed together. It is only ever actually selected when nothing
+  // else matched, so it changes nothing for the common case where the value
+  // does match an option.
+  //
+  // Bails (leaves prior behaviour) whenever the option set isn't fully
+  // statically known — a `.map()`-rendered list has an unknown number of
+  // rows at compile time, so there is no finite OR to negate.
+  const matchConditions: ExpressionAttr[] = []
+  let optionSetIsDynamic = false
+
   const distribute = (nodes: IRNode[]): void => {
     for (const n of nodes) {
+      if (n.type === 'text') continue
       if (n.type === 'element' && n.tag === 'option') {
-        if (n.attrs.some(a => a.name === 'selected')) continue
+        if (n.attrs.some(a => a.name === 'selected')) {
+          optionSetIsDynamic = true
+          continue
+        }
         const optValue = n.attrs.find(a => a.name === 'value')
-        if (!optValue) continue
+        if (!optValue) {
+          // No `value` attr: the browser falls back to the option's text
+          // content as its implicit value, which this pass can't compare
+          // against without re-deriving that text — bail rather than
+          // silently dropping this option out of the "no match" OR.
+          optionSetIsDynamic = true
+          continue
+        }
         if (optValue.value.kind === 'literal') {
-          n.attrs.push({ name: 'selected', value: selectedForLiteral(optValue.value.value), loc: n.loc })
+          const selected = selectedForLiteral(optValue.value.value)
+          n.attrs.push({ name: 'selected', value: selected, loc: n.loc })
+          matchConditions.push(selected)
         } else if (optValue.value.kind === 'expression') {
           const selected = selectedForExpr(optValue.value.expr, optValue.value.templateExpr)
           n.attrs.push({ name: 'selected', value: selected, loc: n.loc })
+          matchConditions.push(selected)
+        } else {
+          // A `value` shape neither builder above can compare (e.g. a
+          // structured `template` part) — same bail, not a silent drop.
+          optionSetIsDynamic = true
         }
-      } else if (
-        n.type === 'fragment' ||
-        n.type === 'loop' ||
-        (n.type === 'element' && n.tag === 'optgroup')
-      ) {
+      } else if (n.type === 'fragment' || (n.type === 'element' && n.tag === 'optgroup')) {
+        distribute(n.children)
+      } else if (n.type === 'loop') {
+        // A `.map()`-rendered option list still needs its per-row `selected`
+        // distributed (#2466, preserved below) — but its row count is
+        // unknown at compile time, so it can't feed the "no match" OR.
+        optionSetIsDynamic = true
         distribute(n.children)
+      } else {
+        // Conditionals/if-statements, components, slots — an option here
+        // may or may not exist at runtime, so the option set can't be
+        // exhaustively enumerated at compile time.
+        optionSetIsDynamic = true
       }
     }
   }
   distribute(children)
+
+  if (optionSetIsDynamic || matchConditions.length === 0) return
+  if (isMultiSelection(attrs)) return
+
+  const orExpr = matchConditions.map(c => `(${c.expr})`).join(' || ')
+  const orTemplateExpr = matchConditions.some(c => c.templateExpr !== undefined)
+    ? matchConditions.map(c => `(${c.templateExpr ?? c.expr})`).join(' || ')
+    : undefined
+
+  children.unshift({
+    type: 'element',
+    tag: 'option',
+    attrs: [
+      { name: 'value', value: AttrValueOf.literal(''), loc: valueAttr.loc },
+      { name: 'disabled', value: AttrValueOf.booleanAttr(), loc: valueAttr.loc },
+      { name: 'hidden', value: AttrValueOf.booleanAttr(), loc: valueAttr.loc },
+      {
+        name: 'selected',
+        value: AttrValueOf.expression(
+          `!(${orExpr})`,
+          orTemplateExpr !== undefined ? { templateExpr: `!(${orTemplateExpr})` } : undefined,
+        ),
+        loc: valueAttr.loc,
+      },
+    ],
+    events: [],
+    ref: null,
+    children: [],
+    slotId: null,
+    needsScope: false,
+    loc: valueAttr.loc,
+  })
+}
+
+/** `<select multiple>` or `size` > 1: a list box has no implicit default
+ *  selection, so SSR (no option `selected`) and hydration (`selectedIndex`
+ *  left at whatever it was) already agree without a placeholder option. */
+function isMultiSelection(attrs: IRAttribute[]): boolean {
+  if (attrs.some(a => a.name === 'multiple')) return true
+  const sizeAttr = attrs.find(a => a.name === 'size')
+  return sizeAttr?.value.kind === 'literal' && Number(sizeAttr.value.value) > 1
 }
 
 function transformHtmlElement(
@@ -2334,7 +2429,13 @@ function transformExpressionInner(
     // A reactive brand-package condition (e.g. `form.field('x').error() &&
     // …`) can't be SSR-evaluated, so defer the whole conditional rather
     // than raising BF061 — same routing as a manual `/* @client */` (#1638).
-    if ((isClientOnly || shouldAutoDeferReactiveBrand(expr, ctx)) && ir.type === 'conditional') {
+    // Check `ir.type` first: `shouldAutoDeferReactiveBrand` only matters for
+    // IRConditional, but walks the checker over `expr` — for every other
+    // shape (in particular IRLoop, whose `expr` is a `.map()` callback body
+    // full of JSX) that walk is both wasted work and, historically, exactly
+    // what tripped the getJS trust-boundary assertion on a JSX-bearing node
+    // (#2867/#2830).
+    if (ir.type === 'conditional' && (isClientOnly || shouldAutoDeferReactiveBrand(expr, ctx))) {
       ir.clientOnly = true
       if (!ir.slotId) {
         ir.slotId = generateSlotId(ctx)
@@ -8115,10 +8216,21 @@ function isReactiveExpression(expr: string, ctx: TransformContext, astNode?: ts.
 function shouldAutoDeferReactiveBrand(expr: ts.Expression, ctx: TransformContext): boolean {
   const checker = ctx.analyzer.checker
   if (!checker) return false
-  if (!containsReactiveExpression(expr, checker)) return false
+  // Read only the brand-carrying leaf(s), never `expr` itself: `expr` can be
+  // a `.map()` callback or a ternary/`&&` with JSX arms, and getJS() refuses
+  // to stringify a JSX-bearing node (the write-side trust boundary — JSX
+  // must travel as structured segments, never raw text). Each leaf is an
+  // identifier / property access / call callee, none of which can contain
+  // JSX, so getJS() is safe on them regardless of what the rest of `expr`
+  // contains (#2867/#2830 — this used to call getJS(expr) directly and
+  // throw whenever the checker was active and expr had JSX in it).
+  const leaves = collectReactiveBrandLeaves(expr, checker)
+  if (leaves.length === 0) return false
   // Native signals/memos (incl. chained-const aliases) are SSR-derivable —
   // leave them to the normal template path so their initial value renders.
-  if (isSignalOrMemoReference(ctx.getJS(expr), ctx)) return false
+  // Preserves the original "any native ref anywhere defers to non-deferred"
+  // semantics by checking every reactive-brand leaf, not just the first.
+  if (leaves.some((leaf) => isSignalOrMemoReference(ctx.getJS(leaf), ctx))) return false
   return true
 }
 

package/src/prop-rewrite.ts

@@ -105,9 +105,14 @@ function isNonValuePosition(n: ts.Identifier, parent: ts.Node | undefined): bool
 /**
  * Walk an AST node for destructured-prop value references and add
  * each found name to `out`. Same skip rules as the rewrite path —
- * object-literal keys, shorthand properties, property-access names,
- * and names shadowed by a binding inside `node` are excluded so only
- * true value references get picked up. Exported for callers that need
+ * object-literal keys, property-access names, and names shadowed by a
+ * binding inside `node` are excluded so only true value references get
+ * picked up. A shorthand property (`{ page }`) IS a value reference —
+ * its name is simultaneously the key and the value, and
+ * `applyScopedPropRefRewrite` below already expands it correctly
+ * (`{ page }` → `{ page: _p.page }`) — so it must be discovered here
+ * too, or the rewrite is never even attempted for text whose only prop
+ * reference is a shorthand one (#2828). Exported for callers that need
  * the raw discovery set (e.g. the branch-local prop-dep cache from
  * #1425).
  */
@@ -118,7 +123,6 @@ export function collectAstPropRefs(
 ): void {
   walkWithScope(node, (n, parent, shadowed) => {
     if (shadowed || !propNames.has(n.text)) return
-    if (parent && ts.isShorthandPropertyAssignment(parent) && parent.name === n) return
     if (isNonValuePosition(n, parent)) return
     out.add(n.text)
   })

package/src/props-binding.ts

@@ -1,5 +1,5 @@
 import ts from 'typescript'
-import type { ParamInfo } from './types.ts'
+import type { ConstantInfo, ParamInfo } from './types.ts'
 
 /**
  * Authoritative IdentifierName classification for a destructure-pattern
@@ -69,6 +69,42 @@ export function buildPropAliasMap(params: readonly ParamInfo[]): Map<string, str
   return map
 }
 
+/**
+ * Local-name → caller-facing-key map for a BARE-PROPS-form component
+ * (`function Foo(props: Props)`) whose BODY destructures a prop under a
+ * different local name (`const { children: kids } = props`) — the
+ * body-level twin of `buildPropAliasMap` above, which only sees
+ * PARAMETER-destructuring aliases (`{ n: count }`, tracked via
+ * `ParamInfo.sourceName`). For the bare-props form, `propsParams` comes
+ * from the TYPE annotation (`extractPropsFromTypeMembers`) and has no
+ * notion of a body-level rename at all — but the analyzer already
+ * resolves such a destructuring statement into an ordinary
+ * `localConstants` entry whose `parsed` is a plain `props.<key>` member
+ * read (`const { children: kids } = props` → a `kids` local const valued
+ * `props.children`). Recognizing that shape here is enough to answer
+ * "what caller-facing prop key does this local alias" without a second,
+ * dedicated AST walk of the destructuring pattern itself (#2788).
+ *
+ * Returns an empty map for a parameter-destructuring component
+ * (`propsObjectName === null`) — that shape's aliasing is already fully
+ * covered by `buildPropAliasMap`.
+ */
+export function resolveBodyDestructuredPropAliases(
+  localConstants: readonly ConstantInfo[],
+  propsObjectName: string | null,
+): Map<string, string> {
+  const aliases = new Map<string, string>()
+  if (propsObjectName === null) return aliases
+  for (const c of localConstants) {
+    if (c.isModule) continue
+    const m = c.parsed
+    if (m?.kind === 'member' && !m.computed && m.object.kind === 'identifier' && m.object.name === propsObjectName) {
+      aliases.set(c.name, m.property)
+    }
+  }
+  return aliases
+}
+
 /**
  * The props-parameter shape needed to answer "is `name` an actual local
  * binding introduced by the props parameter" — as opposed to

package/src/reactivity-checker.ts

@@ -191,3 +191,63 @@ export function containsReactiveExpression(node: ts.Node, checker: ts.TypeChecke
   incrementCounter('reactivityChecks')
   return brandTypeReactivityAnalyzer.analyze(node, checker).isReactive
 }
+
+/** Subtree JSX check — also used by analyzer-context.ts's getJS() guard. */
+export function nodeContainsJsx(node: ts.Node): boolean {
+  if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node)) return true
+  return ts.forEachChild(node, nodeContainsJsx) ?? false
+}
+
+/**
+ * Every node that itself carries the `Reactive<T>` brand within `node`,
+ * without stopping at the first match (unlike `analyze`, which only needs
+ * one hit to answer "is this reactive"). A caller that needs to read the
+ * *text* of the reactive part(s) — e.g. to tell a brand-package wrapper
+ * apart from a plain native signal/memo call (#2867) — must not stringify
+ * `node` itself: for a `.map()` callback or a ternary with JSX arms, `node`
+ * is JSX-bearing, and the write-side trust boundary (`getJS()`,
+ * `analyzer-context.ts`) rejects producing text for a JSX-bearing node.
+ * Each returned node is JSX-free: property access and identifier leaves
+ * cannot contain JSX by construction; a call leaf is the whole call
+ * (preserving the `name(...)` shape native-signal/memo regex patterns
+ * match against) unless its arguments happen to contain JSX, in which case
+ * only the callee is returned instead.
+ */
+export function collectReactiveBrandLeaves(node: ts.Node, checker: ts.TypeChecker): ts.Node[] {
+  const leaves: ts.Node[] = []
+  const visit = (n: ts.Node): void => {
+    if (ts.isPropertyAccessExpression(n)) {
+      try {
+        if (isReactiveType(queryType(checker, n))) {
+          leaves.push(n)
+          return
+        }
+      } catch {
+        // fall through to walking the object part
+      }
+      visit(n.expression)
+      return
+    }
+    if (ts.isIdentifier(n)) {
+      try {
+        if (isReactiveType(queryType(checker, n))) leaves.push(n)
+      } catch {
+        // not reactive
+      }
+      return
+    }
+    if (ts.isCallExpression(n)) {
+      try {
+        if (isReactiveType(queryType(checker, n.expression))) {
+          leaves.push(nodeContainsJsx(n) ? n.expression : n)
+          return
+        }
+      } catch {
+        // fall through to walking children
+      }
+    }
+    ts.forEachChild(n, visit)
+  }
+  visit(node)
+  return leaves
+}

package/src/ssr-defaults.ts

@@ -31,6 +31,8 @@
 
 import ts from 'typescript'
 import { extractFreeIdentifiersFromNode } from './analyzer.ts'
+import { resolveGetterAliases, collectAliasableGetterNames } from './ir-to-client-js/csr-substitute.ts'
+import { resolveBodyDestructuredPropAliases } from './props-binding.ts'
 import type { IRMetadata } from './types.ts'
 
 /**
@@ -311,6 +313,49 @@ export function extractSsrDefaults(metadata: IRMetadata): Record<string, SsrDefa
     bindings[memo.name] = value
   }
 
+  // #2813: a bare local-const alias of a signal/memo getter
+  // (`const items__alias = items`) is a DIFFERENT identifier from the
+  // getter it aliases, but a template-stash adapter's `.map()` loop over
+  // `items__alias()` looks up the stash entry BY THAT NAME — which the
+  // loops above never create, since they only seed the getter's own
+  // name. Reuses `resolveGetterAliases` (the same alias-hop walker
+  // #2778's CSR-template fix introduced) rather than a third alias-hop
+  // walker: every alias of a getter seeded above gets the SAME entry
+  // under its own name, so the stash has both `items` and `items__alias`
+  // pointing at one value. Env-signal getters are excluded from the
+  // getter-name set (they're never given an `out` entry above — an
+  // adapter's own env-signal binding seeds them instead).
+  {
+    const getterNames = collectAliasableGetterNames(metadata.signals, metadata.memos)
+    for (const [alias, origin] of resolveGetterAliases(metadata.localConstants ?? [], (n) => getterNames.has(n))) {
+      if (alias in out) continue
+      out[alias] = out[origin]
+    }
+  }
+
+  // #2788: a bare-props-form component (`function Foo(props: Props)`)
+  // whose BODY destructures a prop under a different local name
+  // (`const { children: kids } = props`) has no `ParamInfo.sourceName` to
+  // key off above — `propsParams` here comes from the TYPE annotation
+  // (`extractPropsFromTypeMembers`), which has no notion of a body-level
+  // rename. `resolveBodyDestructuredPropAliases` recognizes such a
+  // destructuring statement's `localConstants` shape; seeding the LOCAL
+  // name too (alongside the caller-facing key already seeded above) is
+  // enough to fix what a template-stash adapter's compiled output
+  // actually reads (`v[:kids]` / `$kids`). Without this, a stash-based
+  // adapter reading the renamed local sees an undefined/nil value instead
+  // of the prop — fatal under Perl strict mode (Mojolicious), a
+  // nonexistent Go struct field, or (on an adapter whose runtime
+  // tolerates a missing key) a silent wrong render the moment a caller
+  // actually supplies a value. Parameter-destructuring aliases (`{ n:
+  // count }`) need no such entry — `sourceName`/`name` already handle
+  // that shape via `callerPropName` above.
+  for (const [local, callerKey] of resolveBodyDestructuredPropAliases(metadata.localConstants ?? [], metadata.propsObjectName)) {
+    if (local in out) continue
+    const origin = out[callerKey]
+    if (origin) out[local] = origin
+  }
+
   // Bare-props-arg safety net: the prop block above covers every prop
   // *declared* on the props type, but `propsParams` can miss props read
   // through an untyped / inline-typed `props` object. A signal / memo

package/src/types.ts

@@ -404,18 +404,13 @@ export interface IRText {
 export interface IRExpression {
   type: 'expression'
   expr: string
-  /** Pre-transformed expr with destructured prop refs rewritten to _p.xxx (for client JS templates). */
-  templateExpr?: string
   /**
-   * Marks a VALUE moved into element content by a lowering (today only
-   * `lowerFormControlValueSsr`'s `<textarea>`, #2765) — client builders
-   * must escape it, unlike the normal pre-rendered-HTML `${...}` case.
-   *
-   * Not read via `templateExpr` instead: that field also rebinds to
-   * `_p.xxx`, which drops a destructured prop's `?? {}` default when the
-   * builder's output lives in init scope (`client-js-generation.test.ts`).
+   * Pre-transformed expr with destructured prop refs rewritten to _p.xxx
+   * (for client JS templates). Carries ONLY that rewrite — never an
+   * escaping wrapper: client-side escaping is decided at the splice
+   * (`ir-to-client-js/safe-html.ts`), not baked into IR text (#2795).
    */
-  escapeInClientTemplate?: boolean
+  templateExpr?: string
   /**
    * Structured parse of `expr` (`parseExpression(expr.trim())`), attached once
    * during IR construction so SSR adapters emit from the tree instead of each

package/src/__tests__/text-slot-escaping.test.ts

@@ -1,65 +0,0 @@
-/**
- * Text-slot HTML-escaping emit shape (#1694 + follow-up, #2651).
- *
- * Pins which interpolations the client template wraps in an escape call:
- *   - a plain, non-conditional dynamic text slot (`{stringValue}`) IS
- *     escaped — it becomes the slot's text content under `innerHTML`. Since
- *     #2651 this goes through `escapeTextOrMarkup`, not bare `escapeText`:
- *     the slot is claim-plan `kind: 'markup'` (the value may be a live
- *     `Node`, or a `bfMarkup()`-branded JSX-element-prop value), and
- *     `escapeTextOrMarkup` is a strict superset of `escapeText` for every
- *     non-branded value — this pin's actual escaping behaviour for a plain
- *     string is unchanged, only the call name changed to match the
- *     REACTIVE side's existing `escapeTextOrNode` classification;
- *   - a branch-slot expression (Child-position value inside a conditional
- *     `template()` arrow) is routed through `__bfSlot` and must NOT be
- *     wrapped in either escape call. `__bfSlot` returns raw
- *     `<!--bf-slot:N-->` markers for live nodes; escaping the whole call
- *     corrupts them and drops slotted content (the regression that broke
- *     `e2e-site-ui`). `__bfSlot` escapes its own plain-string path
- *     internally instead.
- */
-
-import { describe, test, expect } from 'bun:test'
-import { compileJSX } from '../compiler'
-import { TestAdapter } from '../adapters/test-adapter'
-
-const adapter = new TestAdapter()
-
-function getClientJs(source: string, filename: string): string {
-  const result = compileJSX(source, filename, { adapter })
-  expect(result.errors.filter(e => e.severity === 'error')).toHaveLength(0)
-  const clientJs = result.files.find(f => f.type === 'clientJs')
-  expect(clientJs).toBeDefined()
-  return clientJs!.content
-}
-
-describe('text-slot escaping', () => {
-  test('a plain text slot is wrapped in escapeTextOrMarkup (#2651)', () => {
-    const clientJs = getClientJs(
-      `'use client'
-       export function Label({ text }: { text: string }) {
-         return <span>{text}</span>
-       }`,
-      'Label.tsx',
-    )
-    expect(clientJs).toMatch(/<!--bf:\w+-->\$\{escapeTextOrMarkup\(_p\.text\)\}<!--\/-->/)
-  })
-
-  test('a branch-slot expression is NOT wrapped in escapeTextOrMarkup or escapeText', () => {
-    const clientJs = getClientJs(
-      `'use client'
-       import { createSignal } from '@barefootjs/client'
-       export function Branch({ show }: { show: boolean }) {
-         const [t] = createSignal('hi')
-         return <div>{show ? <span>{t()}</span> : null}</div>
-       }`,
-      'Branch.tsx',
-    )
-    // The branch value goes through __bfSlot (raw markers preserved)…
-    expect(clientJs).toMatch(/\$\{__bfSlot\(/)
-    // …and must never be double-wrapped by either text-escape call.
-    expect(clientJs).not.toMatch(/escapeTextOrMarkup\(\s*__bfSlot/)
-    expect(clientJs).not.toMatch(/escapeText\(\s*__bfSlot/)
-  })
-})