@barefootjs/go-template 0.18.7 → 0.19.1

package/src/adapter/go-template-adapter.ts

@@ -135,7 +135,7 @@ import { lowerCtorExpr } from "./memo/ctor-lowering.ts"
 import { resolveBlockBodyMemoModuleConst } from "./memo/memo-value.ts"
 import { computeMemoInitialValue, computeMemoInitialValueOrNull, filterArmEarlierSiblingRefs } from "./memo/memo-compute.ts"
 import { collectSpreadSlots, buildSpreadInitializer } from "./spread/spread-codegen.ts"
-import { buildPropTypeOverrides, resolvePropGoType, collectNillablePropNames } from "./props/prop-types.ts"
+import { buildPropTypeOverrides, resolvePropGoType, collectNillablePropNames, collectNullishConsumedPropNames, collectOmittableAttrConsumedPropNames, collectTextConsumedPropNames, collectPresenceCheckedPropNames, NULLISH_SCALAR_GO_TYPES } from "./props/prop-types.ts"
 import { collectStringValueNames } from "./props/prop-classes.ts"
 
 export type { GoTemplateAdapterOptions } from "./lib/types.ts"
@@ -224,8 +224,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       this.convertExpressionToGo(jsExpr, out, preParsed),
     convertConditionToGo: (jsCondition, preParsed) =>
       this.convertConditionToGo(jsCondition, preParsed),
-    extractPropNameFromInitialValue: (initialValue) => this.extractPropNameFromInitialValue(initialValue),
-    extractPropFallback: (initialValue) => this.extractPropFallback(initialValue),
+    extractPropNameFromInitialValue: (initialValue, preParsed) =>
+      this.extractPropNameFromInitialValue(initialValue, preParsed),
+    extractPropFallback: (initialValue, preParsed) => this.extractPropFallback(initialValue, preParsed),
     resolveModuleStringConst: (name) => this.resolveModuleStringConst(name),
   }
 
@@ -406,6 +407,21 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     }
     this.state.loweringMatchers = prepareLoweringMatchers(ir.metadata)
     augmentInheritedPropAccesses(ir)
+    // The consumed-prop sets feed `resolvePropGoType`'s interface{} flips
+    // (#2248/#2259) and `collectNillablePropNames` is derived from
+    // `resolvePropGoType`, which also consults the local type tables — so
+    // build the tables first and populate all three HERE, where both entry
+    // points share them. Computing them only in `generate()` left the
+    // standalone `generateTypes()` entry (sibling IRs in the conformance
+    // harness) resolving structs against another component's sets, and
+    // `generate()` itself computing nillability against the PREVIOUS
+    // compile's type tables.
+    this.buildLocalTypeTables(ir, ir.metadata.componentName)
+    this.state.nullishConsumedPropNames = collectNullishConsumedPropNames(this.emitCtx, ir)
+    this.state.omittableAttrConsumedPropNames = collectOmittableAttrConsumedPropNames(this.emitCtx, ir)
+    this.state.textConsumedPropNames = collectTextConsumedPropNames(this.emitCtx, ir)
+    this.state.presenceCheckedPropNames = collectPresenceCheckedPropNames(this.emitCtx, ir)
+    this.state.nillablePropNames = collectNillablePropNames(this.emitCtx, ir)
   }
 
   /** Generate template output for a component. */
@@ -416,7 +432,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     this.state.templateVarCounter = 0
     this.state.pendingChildrenDefines = []
     this.primeCompileState(ir)
-    this.state.nillablePropNames = collectNillablePropNames(this.emitCtx, ir)
     this.state.stringValueNames = collectStringValueNames(ir)
 
     // Surface loop-body usages of sibling-imported components (see
@@ -1213,10 +1228,26 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     // from an omitted field, so it also fires on the type's zero value.
     const propFallbackVars = this.collectPropFallbackVars(ir)
     for (const [, info] of propFallbackVars) {
-      lines.push(`\t${info.varName} := in.${info.fieldName}`)
-      lines.push(`\tif ${info.varName} == ${info.zeroLiteral} {`)
-      lines.push(`\t\t${info.varName} = ${info.goFallback}`)
-      lines.push(`\t}`)
+      if (info.assertType) {
+        // Nillable-lowered prop (#2248): the `interface{}` field makes
+        // "absent" (nil) distinguishable from an explicit `''`/`0`/`false`,
+        // so the fallback applies ONLY on nil — JS `??` semantics. Numbers
+        // coerce through the runtime (an untyped `Size: 3` literal boxes as
+        // int even into a float64-shaped prop); string/bool assert directly.
+        const deref =
+          info.assertType === 'int' ? `bf.ToInt(in.${info.fieldName})`
+          : info.assertType === 'float64' ? `bf.ToFloat64(in.${info.fieldName})`
+          : `in.${info.fieldName}.(${info.assertType})`
+        lines.push(`\tvar ${info.varName} ${info.assertType} = ${info.goFallback}`)
+        lines.push(`\tif in.${info.fieldName} != nil {`)
+        lines.push(`\t\t${info.varName} = ${deref}`)
+        lines.push(`\t}`)
+      } else {
+        lines.push(`\t${info.varName} := in.${info.fieldName}`)
+        lines.push(`\tif ${info.varName} == ${info.zeroLiteral} {`)
+        lines.push(`\t\t${info.varName} = ${info.goFallback}`)
+        lines.push(`\t}`)
+      }
     }
     if (propFallbackVars.size > 0) lines.push('')
 
@@ -1325,7 +1356,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       if (propFieldNames.has(fieldName)) continue
       // `props.X ?? N` reuses the hoisted fallback var so signal and memo share
       // one value.
-      const fallbackMatch = this.extractPropFallback(signal.initialValue)
+      const fallbackMatch = this.extractPropFallback(signal.initialValue, signal.parsed)
       const hoisted = fallbackMatch ? propFallbackVars.get(fallbackMatch.propName) : undefined
       if (hoisted) {
         lines.push(`\t\t${fieldName}: ${hoisted.varName},`)
@@ -2715,8 +2746,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       localTaken.add(`${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`)
     }
 
+    const propTypeOverrides = buildPropTypeOverrides(this.emitCtx, ir)
     for (const signal of ir.metadata.signals) {
-      const match = this.extractPropFallback(signal.initialValue)
+      const match = this.extractPropFallback(signal.initialValue, signal.parsed)
       if (!match) continue
       if (result.has(match.propName)) continue
       const param = ir.metadata.propsParams.find(p => p.name === match.propName)
@@ -2724,6 +2756,14 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // A destructure default already wins via applyGoFallback below.
       if (goPropDefault(param.defaultValue) !== null) continue
       const fieldName = capitalizeFieldName(match.propName)
+      // A `??`-consumed optional scalar lowered to `interface{}` (#2248) —
+      // detected off the SAME `resolvePropGoType` pipeline the struct
+      // generators use, so this can't drift from the emitted field type. The
+      // concrete pre-flip type is what the hoisted local materializes as.
+      const concreteType = propTypeOverrides.get(param.name) ?? typeInfoToGo(this.emitCtx, param.type, param.defaultValue)
+      const nullishLowered =
+        NULLISH_SCALAR_GO_TYPES.has(concreteType) &&
+        resolvePropGoType(this.emitCtx, param, propTypeOverrides) === 'interface{}'
       // Pick the zero literal based on the fallback's literal shape. Bool
       // fallbacks (`?? true`) hoist against the `false` zero — the same Go-zero
       // conflation the int / string cases accept: the caller can't distinguish
@@ -2742,8 +2782,16 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       // (`?? 0`, `?? ''`, `?? false`, `?? 0.0`). Compare against the computed
       // zeroLiteral so spelling variants like `0.0` collapse to the same skip
       // as `0`.
-      if (match.goFallback === zeroLiteral) continue
-      if (zeroLiteral === '0' && Number(match.goFallback) === 0) continue
+      //
+      // NOT a no-op for a nillable-lowered prop (#2248): its `interface{}`
+      // field can be nil, and the typed hoisted local is what downstream
+      // consumers (`Count: size`, memo env maps) assign from — a nil
+      // interface into a concrete field is a compile error, so the local
+      // must exist even when the fallback equals the zero value.
+      if (!nullishLowered) {
+        if (match.goFallback === zeroLiteral) continue
+        if (zeroLiteral === '0' && Number(match.goFallback) === 0) continue
+      }
       // The JSX-side identifier is the natural local name; suffix with `_` if it
       // collides with a Go keyword or a local we already emit.
       let varName = match.propName
@@ -2751,21 +2799,43 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         varName += '_'
       }
       localTaken.add(varName)
-      result.set(match.propName, { varName, fieldName, goFallback: match.goFallback, zeroLiteral })
+      result.set(match.propName, {
+        varName,
+        fieldName,
+        goFallback: match.goFallback,
+        zeroLiteral,
+        ...(nullishLowered ? { assertType: concreteType } : {}),
+      })
     }
     return result
   }
 
   /**
-   * Parse a signal-time initial value of the form `props.X ?? <literal>` into
-   * the source prop name and the Go-formatted fallback. Returns null when the
-   * expression isn't a `??` against a property access on `propsObjectName`, or
-   * the fallback isn't a simple literal `goPropDefault` can translate.
+   * Parse a signal-time initial value of the form `props.X ?? <literal>` —
+   * or, for destructured components, `x ?? <literal>` — into the source prop
+   * name and the Go-formatted fallback. Returns null when the expression
+   * isn't that shape or the fallback isn't a simple literal `goPropDefault`
+   * can translate.
+   *
+   * `preParsed` (the signal's best-effort `ParsedExpr`) is matched
+   * structurally when available; the regex handles only the props-object
+   * member form for callers without a tree (memo computations). A bare
+   * identifier can shadow a same-named prop (loop/callback params — the
+   * `collectNullishConsumedPropNames` limitation class), so every caller
+   * validates the returned name against `ir.metadata.propsParams`.
    *
    * Keeps the original prop reference (not just the resolved value) so
    * caller-supplied non-zero inputs are honoured.
    */
-  private extractPropFallback(initialValue: string): { propName: string; goFallback: string } | null {
+  private extractPropFallback(
+    initialValue: string,
+    preParsed?: ParsedExpr,
+  ): { propName: string; goFallback: string } | null {
+    const structural = preParsed ? this.extractPropFallbackFromParsed(preParsed) : null
+    if (structural) return structural
+
+    // Regex fallback for callers without a tree (memo computation strings)
+    // and for props-object shapes the structural match doesn't model.
     if (!this.state.propsObjectName) return null
     const trimmed = initialValue.trim()
     const name = this.state.propsObjectName
@@ -2779,12 +2849,64 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return { propName: m[1], goFallback }
   }
 
+  /** Structural half of {@link extractPropFallback}. */
+  private extractPropFallbackFromParsed(
+    preParsed: ParsedExpr,
+  ): { propName: string; goFallback: string } | null {
+    if (preParsed.kind !== 'logical' || preParsed.op !== '??') return null
+    const left = preParsed.left
+    const propName =
+      left.kind === 'identifier' && !this.state.propsObjectName
+        ? left.name
+        : left.kind === 'member' &&
+            !left.computed &&
+            left.object.kind === 'identifier' &&
+            left.object.name === this.state.propsObjectName
+          ? left.property
+          : null
+    if (!propName) return null
+    // A negative fallback (`?? -1`) parses as unary minus around a number
+    // literal, not a literal.
+    let right = preParsed.right
+    let negate = ''
+    if (right.kind === 'unary' && right.op === '-') {
+      negate = '-'
+      right = right.argument
+    }
+    if (right.kind !== 'literal') return null
+    if (negate && right.literalType !== 'number') return null
+    // A string fallback is already the decoded value — quote it directly;
+    // routing it through `goPropDefault` would strip JSON.stringify's outer
+    // quotes and escape the body a second time (`"` → `\\\"`).
+    if (right.literalType === 'string') {
+      return { propName, goFallback: JSON.stringify(right.value) }
+    }
+    // Numbers keep their source spelling when available (`raw` is only
+    // populated for numbers); booleans/null stringify losslessly.
+    const goFallback = goPropDefault(negate + (right.raw ?? String(right.value)))
+    if (goFallback === null) return null
+    return { propName, goFallback }
+  }
+
   /**
    * Extract the prop name from a signal's `props.xxx`-pattern initialValue,
    * e.g. `"props.initial ?? 0"` → `"initial"`, `"props.checked"` → `"checked"`.
+   * For destructured components (`propsObjectName` null) the same shapes are
+   * matched structurally on `preParsed` with an identifier left operand
+   * (`size ?? 0` → `"size"`); callers validate the name against
+   * `propsParams`, which filters shadowing locals.
    */
-  private extractPropNameFromInitialValue(initialValue: string): string | null {
-    if (!this.state.propsObjectName) return null
+  private extractPropNameFromInitialValue(initialValue: string, preParsed?: ParsedExpr): string | null {
+    if (!this.state.propsObjectName) {
+      if (
+        preParsed?.kind === 'logical' &&
+        (preParsed.op === '??' || preParsed.op === '||') &&
+        preParsed.left.kind === 'identifier'
+      ) {
+        return preParsed.left.name
+      }
+      return null
+    }
     const trimmed = initialValue.trim()
     const name = this.state.propsObjectName
 
@@ -2973,13 +3095,52 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       return goExpr
     }
 
+    // A bare TEXT-position reference to an optional no-default scalar prop
+    // that `resolvePropGoType` flipped to nillable `interface{}` (#2267,
+    // `collectTextConsumedPropNames`) needs a nil-safe stringify: plain
+    // `{{.X}}` prints a nil `interface{}` as the literal `<no value>`, not
+    // "" — `bf_string` (the runtime's nil-safe `String()`) prints "" for
+    // nil and formats a present value identically to `text/template`'s own
+    // default printing, so this is a no-op for the non-nil case.
+    const finalExpr =
+      this.textNillablePropNameOf(classify.parsed) !== null
+        ? `bf_string ${wrapIfMultiToken(goExpr)}`
+        : goExpr
+
     // Mark expressions with slotId using comment nodes for client JS to find.
     // This includes reactive expressions AND loop-param-dependent expressions.
     if (expr.slotId) {
-      return `{{bfTextStart "${expr.slotId}"}}{{${goExpr}}}{{bfTextEnd}}`
+      return `{{bfTextStart "${expr.slotId}"}}{{${finalExpr}}}{{bfTextEnd}}`
     }
 
-    return `{{${goExpr}}}`
+    return `{{${finalExpr}}}`
+  }
+
+  /**
+   * The nillable-prop name a bare TEXT-position expression refers to, or
+   * null. Mirrors `nillablePropNameOf` (the `??`-lowering gate) but keys on
+   * `textConsumedPropNames` instead of `nullishConsumedPropNames` — a
+   * text-only optional scalar prop (`{size}`, never consumed by `??` or a
+   * bare omittable attribute) is in neither of those other two sets.
+   */
+  private textNillablePropNameOf(expr: ParsedExpr | undefined): string | null {
+    if (!expr) return null
+    let name: string | null = null
+    if (expr.kind === 'identifier') {
+      name = expr.name
+    } else if (
+      expr.kind === 'member' &&
+      !expr.computed &&
+      expr.object.kind === 'identifier' &&
+      expr.object.name === this.state.propsObjectName
+    ) {
+      name = expr.property
+    }
+    return name !== null &&
+      this.state.textConsumedPropNames.has(name) &&
+      this.state.nillablePropNames.has(name)
+      ? name
+      : null
   }
 
   /**
@@ -3392,7 +3553,13 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     }
 
     const obj = emit(object)
-    if (property === 'length') return `len ${obj}`
+    // JS `.length`: array element count OR, for a string, UTF-16 code-unit
+    // count (#2255) — NOT Go's native `len`, which is byte count for a
+    // string. `Length`/`bf_length` (bf.go) dispatches on the runtime value's
+    // shape to match. The specialized array-only `.length` shapes above
+    // (filter-result count, memo-backed loop slice count) stay on `len`,
+    // since arrays never hit the UTF-16 divergence.
+    if (property === 'length') return `bf_length ${wrapIfMultiToken(obj)}`
     // A `?.`-written access (`user?.name`, #2168 optional-chaining-prop):
     // a plain `.Field` dot-chain panics evaluating a field on a nil
     // interface/pointer (`nil pointer evaluating interface {}.Name`), so
@@ -3526,9 +3693,60 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     const wrapLeft = wrapIfMultiToken(emit(left))
     const wrapRight = wrapIfMultiToken(emit(right))
     if (op === '&&') return `and ${wrapLeft} ${wrapRight}`
+    // `??` on a nillable prop needs true JS nullish semantics (#2248): Go's
+    // `or` is truthiness-based, so `{{or .Label "Default"}}` falls back on a
+    // present-but-empty `""` — JS `??` keeps it. `bf_nullish` tests nil-ness
+    // only. Non-nillable operands keep `or`: their concrete Go type can't
+    // represent "absent" at all, so `or` and `??` are indistinguishable there.
+    if (op === '??' && this.nillablePropNameOf(left) !== null) {
+      return `bf_nullish ${wrapLeft} ${wrapRight}`
+    }
     return `or ${wrapLeft} ${wrapRight}`
   }
 
+  /**
+   * The nillable-prop name a `??` left operand refers to, or null. Matches
+   * the two prop-reference shapes (`label` destructured, `props.label`
+   * object-style) against `nullishConsumedPropNames ∩ nillablePropNames`.
+   *
+   * The intersection matters: `nillablePropNames` alone OVERAPPROXIMATES —
+   * it is collected before local type aliases are registered, so an
+   * alias-typed prop (`placement?: TooltipPlacement`) can sit in the set
+   * while its emitted struct field is the concrete alias type. On such a
+   * concrete field "absent" is invisible (the zero value), so the
+   * truthiness-based `or` is the correct approximation and `bf_nullish`
+   * would wrongly KEEP the zero value (e.g. Tooltip's
+   * `placementClasses[props.placement ?? 'top']` would resolve to no
+   * class for an omitted placement). Requiring `nullishConsumedPropNames`
+   * membership pins the
+   * gate to props the `??` analysis actually saw — the same set that drives
+   * the `interface{}` flip in `resolvePropGoType`.
+   */
+  private nillablePropNameOf(expr: ParsedExpr): string | null {
+    let name: string | null = null
+    if (expr.kind === 'identifier') {
+      name = expr.name
+    } else if (expr.kind === 'member' && !expr.computed && expr.object.kind === 'identifier') {
+      if (expr.object.name === this.state.propsObjectName) {
+        name = expr.property
+      } else {
+        // Single-hop member access rooted at a bare destructured optional
+        // OBJECT prop (`user?.name ?? '…'`, #2256) — the ROOT prop is what
+        // needs to be in the nillable/nullish-consumed sets, not the
+        // accessed field; `member()`'s own `bf_get` lowering for the `?.`
+        // hop already returns Go `nil` on a nil/missing root, so gating on
+        // the root here is sufficient. Mirrors
+        // `collectNullishConsumedPropNames`'s `propNameOfLeft`.
+        name = expr.object.name
+      }
+    }
+    return name !== null &&
+      this.state.nullishConsumedPropNames.has(name) &&
+      this.state.nillablePropNames.has(name)
+      ? name
+      : null
+  }
+
   // JSX-level ternaries (`{expr ? a : b}`) are handled at the IR level as
   // IRConditional (via convertConditionToGo → renderConditionExpr). This method
   // is only reached for ternaries nested inside other ParsedExpr trees (e.g.
@@ -4252,11 +4470,6 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return this.renderFilterExpr(pred, param, new Map(), datumField ?? undefined)
   }
 
-  /** Whether an expression needs parentheses when used in and/or. */
-  private needsParens(expr: ParsedExpr): boolean {
-    return expr.kind === 'logical' || expr.kind === 'unary' || expr.kind === 'conditional'
-  }
-
   /**
    * Split a rendered template block into preamble + final expression.
    * The last `{{...}}` must be a variable reference (`$bf_rN` or
@@ -4935,19 +5148,26 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         if (expr.callee.kind === 'identifier' && expr.args.length === 0) {
           return plain(this.rootFieldRef(expr.callee.name))
         }
-        // `isValidElement(x)` — the framework "is this a renderable element?"
-        // predicate. In the Go SSR children model an element is represented by
-        // its already-rendered markup, so this evaluates faithfully as a
-        // truthiness check on the argument (an element is "valid" when there is
-        // something to render). Lowering it as a real, evaluatable expression —
-        // rather than a fabricated `.IsValidElement` field access — is what lets
-        // the `Slot` dynamic-tag guard register and run cleanly on Go.
+        // `isValidElement(x)` — the framework "is this a renderable element
+        // (not plain text)?" predicate. #2266: a passed-through JSX child is
+        // ALSO represented as pre-rendered markup on Go's SSR model, so a
+        // plain non-empty STRING child is truthy but is NOT a valid element
+        // — a bare truthiness check (the pre-#2266 lowering) wrongly took
+        // `Slot`'s element-merge branch and panicked dereferencing
+        // `.Props`/`.Tag` on a string (`can't evaluate field Props in type
+        // interface {}`). `bf_is_element` (bf.go) does a real reflect-based
+        // shape check (map/struct carrying both `tag`+`props` keys/fields,
+        // case-insensitively), matching JS's `'tag' in x && 'props' in x`.
+        // Pre-parenthesised — `call`-kind results aren't covered by
+        // `needsParens`, so an unparenthesised `bf_is_element X` splices as
+        // extra sibling args into an enclosing `and`/`or`.
         if (
           expr.callee.kind === 'identifier' &&
           (identifierPath(expr.callee) ?? expr.callee.name) === 'isValidElement' &&
           expr.args.length === 1
         ) {
-          return this.renderConditionExpr(expr.args[0])
+          const inner = this.renderConditionExpr(expr.args[0])
+          return { preamble: inner.preamble, expr: `(bf_is_element ${wrapIfMultiToken(inner.expr)})` }
         }
         // Any other user-defined predicate call with arguments (e.g.
         // `isAdmin(user)`) has no server-side evaluator and is not a registered
@@ -5087,11 +5307,27 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         const leftResult = this.renderConditionExpr(expr.left)
         const rightResult = this.renderConditionExpr(expr.right)
         const preamble = leftResult.preamble + rightResult.preamble
-        const wrapLeft = this.needsParens(expr.left) ? `(${leftResult.expr})` : leftResult.expr
-        const wrapRight = this.needsParens(expr.right) ? `(${rightResult.expr})` : rightResult.expr
+        // `wrapIfMultiToken` (whitespace-based, on the RENDERED string) — not
+        // `needsParens` (AST-kind-based, only `logical`/`unary`/`conditional`)
+        // — matches the main `logical()` emitter's own wrapping. `needsParens`
+        // misses any other multi-token rendering (`len .X`, `bf_add a b`,
+        // `.SearchParams.Get "k"`), which `and`/`or`/`bf_nullish` (all prefix
+        // builtins) would otherwise parse as extra sibling args instead of one
+        // operand.
+        const wrapLeft = wrapIfMultiToken(leftResult.expr)
+        const wrapRight = wrapIfMultiToken(rightResult.expr)
+        // `??` on a nillable prop needs true JS nullish semantics (#2254,
+        // sibling of #2248/#2252's fix for text-expression/signal-seed
+        // positions): Go's `or` is truthiness-based, so a present-but-empty
+        // `""`/`0`/`false` operand wrongly falls back. `bf_nullish` tests
+        // nil-ness only. Mirrors the `logical()` emitter's own gate (used
+        // for non-condition expression positions) — same
+        // `nullishConsumed ∩ nillable` check via `nillablePropNameOf`.
         const result = expr.op === '&&'
           ? `and ${wrapLeft} ${wrapRight}`
-          : `or ${wrapLeft} ${wrapRight}`
+          : expr.op === '??' && this.nillablePropNameOf(expr.left) !== null
+            ? `bf_nullish ${wrapLeft} ${wrapRight}`
+            : `or ${wrapLeft} ${wrapRight}`
         return { preamble, expr: result }
       }
 
@@ -5954,17 +6190,22 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     for (const e of entries) {
       if (e.kind === 'expr' && !isSupported(parseExpression(e.expr)).supported) return null
     }
-    // The static CSS key + literal value are inlined into a double-quoted
-    // `style="..."` attribute, so HTML-attr escape them (a value like `'"'`
-    // would otherwise terminate the attribute / inject markup). The dynamic
-    // arm's `{{…}}` action is escaped by `html/template`'s attribute context.
-    return entries
-      .map(e =>
-        e.kind === 'literal'
-          ? `${this.escapeAttrText(e.cssKey)}:${this.escapeAttrText(e.value)}`
-          : `${this.escapeAttrText(e.cssKey)}:{{${this.convertExpressionToGo(e.expr)}}}`,
-      )
-      .join(';')
+    // Routed through the single `bf_style_object` runtime call (#2261)
+    // rather than per-pair `key:value` template interpolation — a dynamic
+    // value that fails the ported `hasUnsafeStyleValue` CSS-injection scan
+    // must DROP its entire pair to match Hono's oracle behavior, which
+    // isn't expressible as a per-pair inline substitution (a dropped
+    // MIDDLE pair would otherwise leave a dangling `key:` / stray `;;` in
+    // a `.map().join(';')` splice). `String()` (already returns "" for
+    // nil) also has an established zero-value contract for numbers/bools,
+    // avoiding html/template's own contextual CSS auto-escaper (whose
+    // `ZgotmplZ` sentinel — the pre-#2261 divergence — is bypassed by the
+    // call returning a trusted `template.CSS`, not a plain `string`).
+    const args = entries.flatMap(e => [
+      JSON.stringify(e.cssKey),
+      e.kind === 'literal' ? JSON.stringify(e.value) : wrapIfMultiToken(this.convertExpressionToGo(e.expr)),
+    ])
+    return `{{bf_style_object ${args.join(' ')}}}`
   }
 
   private renderAttributes(element: IRElement): string {

package/src/adapter/lib/compile-state.ts

@@ -146,6 +146,42 @@ export class CompileState {
    */
   nillablePropNames: Set<string> = new Set()
 
+  /**
+   * OPTIONAL prop names consumed nullish-sensitively (`??` left operand in a
+   * parsed expression tree, or a signal's `props.X ?? <literal>` seed) —
+   * #2248. Consulted by `resolvePropGoType` to flip an optional scalar to the
+   * nillable `interface{}` representation, so it MUST be populated before the
+   * first `resolvePropGoType` call of a compile (see `generate()`'s ordering
+   * against `collectNillablePropNames`).
+   */
+  nullishConsumedPropNames: Set<string> = new Set()
+
+  /**
+   * OPTIONAL no-default prop names consumed as a BARE omittable-attribute
+   * value (`rows={rows}`) — #2259. Same `resolvePropGoType` flip and same
+   * populate-before-first-resolve ordering as `nullishConsumedPropNames`:
+   * the attribute-omission guard (`{{if ne .X nil}}`) needs a nillable field.
+   */
+  omittableAttrConsumedPropNames: Set<string> = new Set()
+
+  /**
+   * OPTIONAL no-default prop names consumed as a BARE TEXT-position
+   * expression value (`{size}`) — #2267. Same `resolvePropGoType` flip and
+   * same populate-before-first-resolve ordering as
+   * `nullishConsumedPropNames`: the text emitter's nil-safe `bf_string`
+   * wrap needs a nillable field to have something to guard.
+   */
+  textConsumedPropNames: Set<string> = new Set()
+
+  /**
+   * OPTIONAL no-default prop names whose PRESENCE is tested — `props.X !==
+   * undefined` (the "controlled component" idiom's `isControlled` memo) —
+   * #2260. Same `resolvePropGoType` flip and same populate-before-first-
+   * resolve ordering as `nullishConsumedPropNames`: distinguishing "caller
+   * passed a value" from "caller omitted the prop" needs a nillable field.
+   */
+  presenceCheckedPropNames: Set<string> = new Set()
+
   /**
    * String-typed signal getter / prop names (#2168 string-concat-plus).
    * Feeds `isStringName` for `isStringConcatBinary`, which decides whether a

package/src/adapter/lib/types.ts

@@ -140,6 +140,15 @@ export interface PropFallbackVar {
   goFallback: string
   /** Go zero literal for the prop's type (`0`, `""`, etc.). */
   zeroLiteral: string
+  /**
+   * Set when the prop lowered to the nillable `interface{}` representation
+   * (#2248): the concrete scalar Go type (`string`/`int`/`float64`/`bool`)
+   * the constructor materializes the hoisted local as. Presence switches
+   * the emission from the zero-value check (`if v == 0`) to a nil check
+   * (`if in.X != nil`), which is what makes an explicit `''`/`0` input
+   * distinguishable from an absent one.
+   */
+  assertType?: string
 }
 
 /**