@barefootjs/go-template 0.18.7 → 0.19.0

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

@@ -119,6 +119,37 @@ runAdapterConformanceTests({
     // (#1897) data-table no longer skipped — loop body children + wrapper
     // struct + block-body memo baking render correctly on Go.
   ]),
+  skipDataPoints: new Set<string>([
+    // #2255 — Go `len` counts bytes; JS counts UTF-16 code units
+    // ('日本語' is 3 in JS, 9 here; '👍' is 2 in JS, 4 here).
+    'string-length-text:multibyte',
+    'string-length-text:astral',
+    // #2256 — the nullish gate covers only BARE nillable prop refs; a
+    // member-access left operand (`user?.name ?? '…'`) still lowers to
+    // the truthiness `or`, so a present-but-empty member falls back.
+    'optional-chaining-prop:empty-name',
+    // #2260 — controlled/derived boolean props: the SSR seed evaluates
+    // only the static fallback of `props.X ?? internal()` chains, so a
+    // caller-supplied true never reaches aria-*/data-state.
+    'toggle:gen:defaultPressed:true',
+    'toggle:gen:pressed:true',
+    'switch:gen:defaultChecked:true',
+    'switch:gen:checked:true',
+    'checkbox:gen:defaultChecked:true',
+    'checkbox:gen:checked:true',
+    // #2261 — invalid dynamic CSS value: html/template emits the
+    // ZgotmplZ sentinel where the oracle drops the property.
+    'style-object-dynamic:gen:color:markup',
+    // #2262 — dynamic `.flat` depth 0/negative renders empty instead of
+    // the contract's shallow copy.
+    'array-flat-dynamic-depth:gen:depth:zero',
+    'array-flat-dynamic-depth:gen:depth:negative',
+    // #2266 — asChild=true with plain-text children: the Slot define
+    // dereferences `.Children.Props.Children`, which hard-errors on a
+    // string child (`can't evaluate field Props in type interface {}`).
+    'button:gen:asChild:true',
+    'kbd:gen:asChild:true',
+  ]),
   onRenderError: (err, id) => {
     if (err instanceof GoNotAvailableError) {
       console.log(`Skipping [${id}]: ${err.message}`)
@@ -506,9 +537,11 @@ export function Counter(props: { initial?: number }) {
       expect(result.types).toBeDefined()
       const types = result.types!
 
-      // Hoist: `initial := in.Initial` + zero-check + fallback assign.
-      expect(types).toContain('initial := in.Initial')
-      expect(types).toMatch(/if initial == 0 \{\s*initial = 99\s*\}/)
+      // The fallback applies only when the prop is ABSENT: an explicit
+      // `Initial: 0` is honoured (JS `0 ?? 99` is `0`, #2248).
+      expect(types).toContain('Initial interface{}')
+      expect(types).toContain('var initial int = 99')
+      expect(types).toMatch(/if in\.Initial != nil \{\s*initial = bf\.ToInt\(in\.Initial\)\s*\}/)
 
       // Prop, signal, and memo all reference the hoisted variable.
       expect(types).toContain('Initial: initial,')
@@ -553,8 +586,11 @@ export function Label(props: { label?: string }) {
 `)
       const result = adapter.generate(ir)
       const types = result.types!
-      expect(types).toContain('label := in.Label')
-      expect(types).toMatch(/if label == ""\s*\{\s*label = "Default"\s*\}/)
+      // An explicit `Label: ""` input stays empty (JS `'' ?? 'Default'` is
+      // `''`, #2248).
+      expect(types).toContain('Label interface{}')
+      expect(types).toContain('var label string = "Default"')
+      expect(types).toMatch(/if in\.Label != nil \{\s*label = in\.Label\.\(string\)\s*\}/)
       expect(types).toContain('Label: label,')
       // Signal name `text` differs from prop name `label`, so the
       // signal field gets its own entry that resolves through the
@@ -562,12 +598,11 @@ export function Label(props: { label?: string }) {
       expect(types).toContain('Text: label,')
     })
 
-    test('hoists `props.X ?? true` against the bool zero (#1423 review)', () => {
-      // Bool-true falls through the same hoist path as int / string —
-      // the asymmetry is documented (caller can't thread "explicit
-      // false" through because Go's bool zero IS false), but emitting
-      // a hoisted local matches the int case's shape so a derived
-      // memo can inherit it.
+    test('hoists `props.X ?? true` against nil (#1423 review, #2248)', () => {
+      // Bool-true falls through the same hoist path as int / string. The
+      // interface{} field is nil only when the caller omitted the prop, so
+      // an explicit `Checked: false` survives (JS `false ?? true` is
+      // `false`).
       const adapter = new GoTemplateAdapter()
       const ir = compileToIR(`
 "use client"
@@ -580,12 +615,124 @@ export function Check(props: { checked?: boolean }) {
 `)
       const result = adapter.generate(ir)
       const types = result.types!
-      expect(types).toContain('checked := in.Checked')
-      expect(types).toMatch(/if checked == false\s*\{\s*checked = true\s*\}/)
+      expect(types).toContain('Checked interface{}')
+      expect(types).toContain('var checked bool = true')
+      expect(types).toMatch(/if in\.Checked != nil \{\s*checked = in\.Checked\.\(bool\)\s*\}/)
       expect(types).toContain('Checked: checked,')
       expect(types).toContain('C: checked,')
     })
 
+    test('hoists the DESTRUCTURED `x ?? N` seed via signal.parsed (#2259)', () => {
+      // Destructured components have no `propsObjectName`, so the seed's
+      // prop reference is a bare identifier — matched structurally on the
+      // signal's ParsedExpr, then routed through the same nullish flip +
+      // hoisted-var machinery as `props.size ?? 1` (#2248/#2252 parity).
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Counter({ size }: { size?: number }) {
+  const [count, setCount] = createSignal(size ?? 1)
+  return <div>{count()}</div>
+}
+`)
+      const result = adapter.generate(ir)
+      const types = result.types!
+      expect(types).toContain('Size interface{}')
+      expect(types).toContain('var size int = 1')
+      expect(types).toMatch(/if in\.Size != nil \{\s*size = bf\.ToInt\(in\.Size\)\s*\}/)
+      expect(types).toContain('Size: size,')
+      expect(types).toContain('Count: size,')
+    })
+
+    test('destructured `x ?? 0` stays concrete and seeds the prop directly (#2259)', () => {
+      // A zero-equivalent fallback earns no nillable flip (nil and the Go
+      // zero value land on the same output), so the field keeps its scalar
+      // type and the signal seeds straight off the input — NOT the literal
+      // `0` the pre-#2259 lowering emitted for the unrecognized identifier
+      // form.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Counter({ size }: { size?: number }) {
+  const [count, setCount] = createSignal(size ?? 0)
+  return <div>{count()}</div>
+}
+`)
+      const result = adapter.generate(ir)
+      const types = result.types!
+      expect(types).toContain('Size int')
+      expect(types).not.toContain('Size interface{}')
+      expect(types).toContain('Size: in.Size,')
+      expect(types).toContain('Count: in.Size,')
+    })
+
+    test('negative fallback (`?? -1`) hoists in both prop styles (#2259 review)', () => {
+      // `-1` parses as unary minus around a number literal, not a literal —
+      // the structural seed match must reconstruct the sign, in the
+      // props-object form (where it preempts the regex path) and the
+      // destructured form alike.
+      for (const [params, ref] of [
+        ['props: { size?: number }', 'props.size'],
+        ['{ size }: { size?: number }', 'size'],
+      ]) {
+        const adapter = new GoTemplateAdapter()
+        const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Counter(${params}) {
+  const [count, setCount] = createSignal(${ref} ?? -1)
+  return <div>{count()}</div>
+}
+`, adapter)
+        const types = adapter.generate(ir).types!
+        expect(types).toContain('Size interface{}')
+        expect(types).toContain('var size int = -1')
+        expect(types).toContain('Count: size,')
+      }
+    })
+
+    test('string fallback with quotes survives the structural match unmangled (#2259 review)', () => {
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Label({ label }: { label?: string }) {
+  const [text, setText] = createSignal(label ?? 'say "hi"')
+  return <div>{text()}</div>
+}
+`, adapter)
+      const types = adapter.generate(ir).types!
+      expect(types).toContain('var label string = "say \\"hi\\""')
+      expect(types).not.toContain('\\\\')
+    })
+
+    test('destructure DEFAULT keeps the concrete-typed applyGoFallback baking (#2259)', () => {
+      // `{ size = 5 }` never sees a nullish binding in JS (the default
+      // already applied), so it must stay excluded from the nillable flip
+      // and keep the zero-check baking on the concrete field.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+"use client"
+import { createSignal } from "@barefootjs/client"
+
+export function Counter({ size = 5 }: { size?: number }) {
+  const [count, setCount] = createSignal(size)
+  return <div>{count()}</div>
+}
+`)
+      const result = adapter.generate(ir)
+      const types = result.types!
+      expect(types).toContain('Size int')
+      expect(types).not.toContain('Size interface{}')
+      expect(types).toContain('Size: func() int { if in.Size == 0 { return 5 }; return in.Size }(),')
+    })
+
     test('skips hoist for zero-equivalent string and float fallbacks (#1423 review)', () => {
       // The skip predicate compares the Go fallback against the
       // type's zero literal — covers `?? ''` (string) and `?? 0.0`
@@ -979,10 +1126,13 @@ function Box({ describedBy }: { describedBy?: string }) {
       // Template emission is unchanged from the proven {...props} path.
       expect(template).toContain('{{bf_spread_attrs .Spread_0}}')
       // The bag value is a conditional map built in NewBoxProps. The
-      // prop type is unresolved (interface{}), so the condition routes
-      // through `bf.Truthy` for a faithful JS `Boolean(x)` test.
+      // optional prop resolves to a concrete `string` (#2259) — it is
+      // consumed only inside the spread condition, not as a bare attr, so
+      // no nillable flip — and the field-typed condition is a faithful
+      // `!= ""` truthiness test rather than reflection: JS string
+      // truthiness IS non-emptiness, and an absent prop zeroes to `""`.
       expect(types).toContain('Spread_0: func() map[string]any {')
-      expect(types).toContain('if bf.Truthy(in.DescribedBy) {')
+      expect(types).toContain('if in.DescribedBy != "" {')
       expect(types).toContain('return map[string]any{"aria-describedby": in.DescribedBy}')
       expect(types).toContain('return map[string]any{}')
     })
@@ -3631,8 +3781,9 @@ export function C(props: Props) {
     const template = result.files?.find(f => f.path.endsWith('.tmpl'))?.content ?? ''
     // The `{}` fallback lowers to the safe `""` Go string sentinel — never the
     // `[UNSUPPORTED: …]` marker text, which would break `text/template` parsing
-    // once spliced as an `or` operand.
-    expect(template).toContain('{{or .Config ""}}')
+    // once spliced as an operand. `??` on a nillable prop lowers to the
+    // nil-testing `bf_nullish` (#2248), equally valid template syntax.
+    expect(template).toContain('{{bf_nullish .Config ""}}')
     expect(template).not.toContain('UNSUPPORTED')
   })
 

package/src/adapter/emit-context.ts

@@ -41,14 +41,23 @@ export interface GoEmitContext {
     preParsed?: ParsedExpr,
   ): { condition: string; preamble: string }
 
-  /** Extract the prop name from a `props.X ?? …` initial value, or null. */
-  extractPropNameFromInitialValue(initialValue: string): string | null
+  /**
+   * Extract the prop name from a `props.X ?? …` initial value — or, given
+   * `preParsed` in a destructured component, an `x ?? …` identifier form —
+   * or null. Callers validate the name against `propsParams`.
+   */
+  extractPropNameFromInitialValue(initialValue: string, preParsed?: ParsedExpr): string | null
 
   /**
-   * Parse a signal-time initial value `props.X ?? <literal>` into the source
-   * prop name and the Go-formatted fallback, or null when it isn't that shape.
+   * Parse a signal-time initial value `props.X ?? <literal>` (or the
+   * destructured `x ?? <literal>` form when `preParsed` is given) into the
+   * source prop name and the Go-formatted fallback, or null when it isn't
+   * that shape. Callers validate the name against `propsParams`.
    */
-  extractPropFallback(initialValue: string): { propName: string; goFallback: string } | null
+  extractPropFallback(
+    initialValue: string,
+    preParsed?: ParsedExpr,
+  ): { propName: string; goFallback: string } | null
 
   /**
    * Inline a module string const by name as a Go double-quoted literal

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, 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,19 @@ 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.nillablePropNames = collectNillablePropNames(this.emitCtx, ir)
   }
 
   /** Generate template output for a component. */
@@ -416,7 +430,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 +1226,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 +1354,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 +2744,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 +2754,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 +2780,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 +2797,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 +2847,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
 
@@ -3526,9 +3646,54 @@ 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' &&
+      expr.object.name === this.state.propsObjectName
+    ) {
+      name = expr.property
+    }
+    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.

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

@@ -146,6 +146,24 @@ 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()
+
   /**
    * 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
 }
 
 /**