@barefootjs/go-template 0.31.9 → 0.32.0

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

@@ -944,7 +944,8 @@ export function List() {
       // A struct is synthesised with one field per inferred key + Go type.
       expect(types).toMatch(/type \w+ struct \{[\s\S]*ID string[\s\S]*N int[\s\S]*Ok bool[\s\S]*\}/)
       // The signal field is a slice of the synthesised struct, not []interface{}.
-      expect(types).toMatch(/Items \[\]\w+ `json:"items"`/)
+      // Excluded from bf-p (json:"-") — component-internal signal state (#2672).
+      expect(types).toMatch(/Items \[\]\w+ `json:"-"`/)
       expect(types).not.toContain('Items []interface{}')
       // The initial items are baked, not nil.
       expect(types).not.toContain('Items: nil,')
@@ -1120,7 +1121,11 @@ export function Rows() {
       expect(types).toContain('DataX string `json:"data-x"`')
       expect(types).not.toContain('"Data-x"')
       expect(types).toContain('Row{ID: "r1", Meta: RowMeta{DataX: "v"}}')
-      expect(types).not.toContain('map[string]interface{}')
+      // `Meta` resolved to the real synthesized struct, not the
+      // `map[string]interface{}` fallback — scoped to the field itself
+      // since `BfCallerProps map[string]interface{}` (#2684) legitimately
+      // appears elsewhere in every generated Props struct now.
+      expect(types).not.toMatch(/Meta map\[string\]interface\{\}/)
     })
 
     test('snake_case keys keep their underscore in the generated field name (#2089 review)', () => {
@@ -1698,6 +1703,56 @@ export function Box({ children }: { children: any }) {
       const types = adapter.generateTypes(ir)!
       expect(types).toMatch(/Children\s+\S+\s+`json:"-"`/)
     })
+
+    test('signal and memo fields are excluded from bf-p serialization — user props only (#2672)', () => {
+      // A signal-bearing component whose only DECLARED prop is `label`, plus
+      // a signal (`count`, not itself a prop) and a memo derived from it
+      // (`doubled`). Only `label` may carry a real json tag — `count` and
+      // `doubled` are component-internal state/derivation the client
+      // re-derives itself and never reads back off `_p`.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+'use client'
+import { createSignal, createMemo } from '@barefootjs/client'
+export function Counter(props: { label: string }) {
+  const [count, setCount] = createSignal(0)
+  const doubled = createMemo(() => count() * 2)
+  return <button onClick={() => setCount(count() + 1)}>{props.label}: {count()} / {doubled()}</button>
+}
+`, adapter)
+      const types = adapter.generateTypes(ir)!
+      // The real prop keeps its real tag — hydration reads `_p.label`.
+      expect(types).toMatch(/Label\s+\S+\s+`json:"label"`/)
+      // The signal field is component-internal state, not caller input.
+      expect(types).toMatch(/Count\s+\S+\s+`json:"-"`/)
+      // The memo field is component-internal derivation, not caller input.
+      expect(types).toMatch(/Doubled\s+\S+\s+`json:"-"`/)
+    })
+
+    test('prop-backed signal default still keeps the PROP field a real tag (#2672)', () => {
+      // Mirrors the `signal-default-from-jsx` adapter-tests fixture: `x` is a
+      // declared PROP whose default happens to come from a signal initial
+      // value (keeps a real tag, seeds client-side `createSignal(_p.x ?? 7)`),
+      // while `incremented` is a pure memo derivation the client never reads
+      // off `_p`. Flipping signal/memo fields to `json:"-"` must NOT touch
+      // this prop field — it is the loop-guard case CLAUDE.md's "don't flip
+      // prop-backed fields" warns against.
+      const adapter = new GoTemplateAdapter()
+      const ir = compileToIR(`
+'use client'
+import { createSignal, createMemo } from '@barefootjs/client'
+export function SignalDefaultFromJsx(props: { x?: number }) {
+  const [x, setX] = createSignal(props.x ?? 7)
+  const incremented = createMemo(() => x() + 1)
+  return <div onClick={() => setX(x() + 1)}>{x()} / {incremented()}</div>
+}
+`, adapter)
+      const types = adapter.generateTypes(ir)!
+      // The prop-backed field keeps its real tag — hydration reads `_p.x`.
+      expect(types).toMatch(/X\s+\S+\s+`json:"x"`/)
+      // The memo field is component-internal derivation, not caller input.
+      expect(types).toMatch(/Incremented\s+\S+\s+`json:"-"`/)
+    })
   })
 
   describe('generateTypes', () => {
@@ -4860,6 +4915,39 @@ export function Counter({ count: initialCount }: { count: number }) {
     expect((types.match(/json:"count"/g) ?? []).length).toBe(1)
   })
 
+  // #2672 near-miss: a prop-derived dynamic loop's nested-array field is
+  // normally redundant (the client re-derives every row from the real prop
+  // field, e.g. `_p.items`) and gets `json:"-"`. But when the array field's
+  // Go name collides with its OWN driving prop's Go name — `toggleItems`
+  // driving a `.map()` into `<ToggleItem>` both capitalize to `ToggleItems`
+  // — `emitPropsDataFields` already shadows the prop's own field to avoid a
+  // Go redeclaration, so the nested-array field is the ONLY struct field
+  // carrying that prop's data. Flipping it to `-` there would silently drop
+  // caller input from `bf-p` instead of trimming a redundant copy. Caught by
+  // the `hydration-props-inventory` oracle against the `toggle-shared`
+  // fixture (a real `integrations/shared/components/Toggle.tsx` shape)
+  // before landing; this pins the same shape directly.
+  test('a prop-derived nested-array field keeps a real tag when it shadows its own driving prop (#2672)', () => {
+    const result = compileJSX(`
+type ToggleItemProps = { label: string; defaultOn?: boolean }
+function ToggleItem(props: ToggleItemProps) {
+  return <div>{props.label}</div>
+}
+type ToggleProps = { toggleItems: ToggleItemProps[] }
+export function Toggle({ toggleItems }: ToggleProps) {
+  return <div>{toggleItems.map((item) => <ToggleItem key={item.label} label={item.label} defaultOn={item.defaultOn} />)}</div>
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    expect((result.errors ?? []).filter(e => e.code === 'BF101')).toHaveLength(0)
+    const types = result.files.find(f => f.type === 'types')!.content
+    const togglePropsAndAfter = types.slice(types.indexOf('type ToggleProps struct'))
+    // The shadowed scalar prop field is absent...
+    expect(togglePropsAndAfter.slice(0, togglePropsAndAfter.indexOf('}'))).not.toMatch(/\bItems\b/)
+    // ...and the nested-array field is the sole carrier, with a REAL tag —
+    // not `json:"-"`, which would drop `toggleItems` from `bf-p` entirely.
+    expect((togglePropsAndAfter.match(/json:"toggleItems"/g) ?? []).length).toBe(1)
+  })
+
   // The nested-array skip check must union both namings at all four sites
   // (`isNestedArrayShadowed`) — a one-sided check lets Input and
   // Props/NewProps disagree on whether an aliased prop's field exists.
@@ -4927,7 +5015,10 @@ export function Foo({ q: searchParams }: { q: string }) {
     expect((result.errors ?? []).filter(e => e.code === 'BF101')).toHaveLength(0)
     const types = result.files.find(f => f.type === 'types')!.content
     const structStart = types.indexOf('type FooProps struct')
-    const fooPropsBody = types.slice(structStart, types.indexOf('}', structStart))
+    // The struct's actual closing brace is the first `}` that starts its
+    // OWN line (fields are tab-indented) — a bare `indexOf('}', ...)` would
+    // stop early at the embedded `}` inside `BfCallerProps map[string]interface{}` (#2684).
+    const fooPropsBody = types.slice(structStart, types.indexOf('\n}', structStart))
     // Exactly one "SearchParams" field in the struct body — the prop's
     // own — never a second `SearchParams bf.SearchParams` reader field
     // colliding with it (a Go redeclaration error).
@@ -4937,6 +5028,188 @@ export function Foo({ q: searchParams }: { q: string }) {
   })
 })
 
+// #2684: `bf-p` must carry only what the caller actually passed — required
+// props always, optional ones only when supplied — never the author's
+// baked default (`x ?? 7`), never `null` for an omitted optional, never a
+// Go zero value standing in for "unset". `NewXxxProps` now ALSO populates a
+// `BfCallerProps map[string]interface{}` sidecar (marshaled by `BfPropsAttr`
+// INSTEAD OF the whole struct) with exactly the caller-supplied, raw
+// (undefaulted) values — see the field's doc comment in
+// `emitPropsStructHeader` for the two-consumers rationale.
+describe('GoTemplateAdapter - BfCallerProps hydration sidecar (#2684)', () => {
+  test('NewXxxProps populates BfCallerProps for the three classes: required, nullish-consumed optional, concrete-typed optional residual', () => {
+    const result = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function C(props: { x?: number; label?: string; name: string }) {
+  const [x] = createSignal(props.x ?? 7)
+  return <div data-name={props.name}>{x()}</div>
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    expect((result.errors ?? []).filter(e => e.code === 'BF101')).toHaveLength(0)
+    const types = result.files.find(f => f.type === 'types')!.content
+    // The sidecar field itself, on the Props struct.
+    expect(types).toContain('BfCallerProps map[string]interface{} `json:"-"`')
+
+    const newProps = types.slice(types.indexOf('func NewCProps'))
+    expect(newProps).toContain('bfCallerProps := map[string]interface{}{}')
+    // Class 1 — required prop: always included, raw `in.Name` (never a
+    // baked/defaulted value — there is none for a required prop anyway).
+    expect(newProps).toContain('bfCallerProps["name"] = in.Name')
+    // Class 2 — optional, nullish-consumed (`??`) prop: flips to `interface{}`
+    // (#2248) and is included ONLY when the caller actually passed something.
+    // Critically, the RAW `in.X` goes in the map, never the baked default
+    // `7` the hoisted fallback var applies to the template-facing field.
+    expect(newProps).toContain('if in.X != nil {')
+    expect(newProps).toContain('bfCallerProps["x"] = in.X')
+    expect(newProps).not.toMatch(/bfCallerProps\["x"\]\s*=\s*7/)
+    // Class 3 — optional prop that resolves to a CONCRETE type (`label` is
+    // never consumed nullish/attr/text/presence-wise, so it stays a plain
+    // `string`): presence is unknowable from Input alone, so it's included
+    // unconditionally — a documented residual, not silently dropped.
+    expect(newProps).toContain('bfCallerProps["label"] = in.Label')
+
+    // The struct literal wires the local into the field.
+    expect(newProps).toContain('BfCallerProps: bfCallerProps,')
+  })
+
+  test('a required nested-array-shadowed prop (#2672/#2525) is carried via its reshaped array local, not silently dropped', () => {
+    const result = compileJSX(`
+type ToggleItemProps = { label: string; defaultOn?: boolean }
+function ToggleItem(props: ToggleItemProps) {
+  return <div>{props.label}</div>
+}
+type ToggleProps = { toggleItems: ToggleItemProps[] }
+export function Toggle({ toggleItems }: ToggleProps) {
+  return <div>{toggleItems.map((item) => <ToggleItem key={item.label} label={item.label} defaultOn={item.defaultOn} />)}</div>
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    expect((result.errors ?? []).filter(e => e.code === 'BF101')).toHaveLength(0)
+    const types = result.files.find(f => f.type === 'types')!.content
+    const newProps = types.slice(types.indexOf('func NewToggleProps'))
+    // The shadowed prop has no `in.ToggleItems` scalar field to read — its
+    // data is carried via the already-built reshaped array local instead.
+    // `toggleItems` is REQUIRED here, so it's unconditional — same
+    // required-stays-unconditional rule as the main loop.
+    expect(newProps).toContain('bfCallerProps["toggleItems"] = toggleItems')
+    expect(newProps).not.toContain('if in.ToggleItems != nil {')
+  })
+})
+
+describe('GoTemplateAdapter - collision-derivation lowering (#2683)', () => {
+  test('a signal colliding with its own prop composes the presence-check fold with the surrounding arithmetic', () => {
+    const result = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function C(props: { count?: number }) {
+  const [count, setCount] = createSignal((props.count ?? 1) * 2)
+  return <span>{count()}</span>
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    expect((result.errors ?? []).filter(e => e.code === 'BF101')).toHaveLength(0)
+    const types = result.files.find(f => f.type === 'types')!.content
+    // The collision flips the field to the nillable representation — the
+    // SAME flip an ordinary `??`-consumed optional prop gets (#2248) — so an
+    // absent prop (nil) and an explicit `0` stay distinguishable.
+    expect(types).toContain('Count interface{}')
+    const newProps = types.slice(types.indexOf('func NewCProps'))
+    // The presence-check fold (`extractPropFallbackFromParsed`'s shape,
+    // reused unchanged) hoists the RAW coalesced value into a local...
+    expect(newProps).toContain('var count int = 1')
+    expect(newProps).toContain('if in.Count != nil {')
+    expect(newProps).toContain('count = bf.ToInt(in.Count)')
+    // ...and the shared field carries the FULLY DERIVED value — the local
+    // with the surrounding `* 2` composed back on, not just the coalesce
+    // result.
+    expect(newProps).toContain('Count: count * 2,')
+    // `BfCallerProps` (#2684) keeps carrying the RAW caller value, never the
+    // derived one.
+    expect(newProps).toContain('if in.Count != nil {')
+    expect(newProps).toContain('bfCallerProps["count"] = in.Count')
+    expect(newProps).not.toMatch(/bfCallerProps\["count"\]\s*=\s*count/)
+  })
+
+  test('a NON-NUMERIC `??` fallback declines collision-derivation — raw passthrough, never invalid Go (Copilot review, #2694)', () => {
+    // `(props.label ?? 'x') + 2` would otherwise hoist `var label string =
+    // "x"` and emit `Label: label + 2,` — invalid Go (string + int), a
+    // compile BREAK where the pre-fix behavior at least built. JS semantics
+    // are string concatenation here besides, so a numeric compose could
+    // never be faithful; the shape stays on the raw-passthrough path.
+    const result = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function C(props: { label?: string }) {
+  const [label, setLabel] = createSignal((props.label ?? 'x') + 2)
+  return <span>{label()}</span>
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    const types = result.files.find(f => f.type === 'types')!.content
+    const newProps = types.slice(types.indexOf('func NewCProps'))
+    expect(newProps).not.toContain('label + 2')
+    expect(newProps).not.toContain('var label string = "x"')
+    // The field keeps the pre-existing raw passthrough.
+    expect(newProps).toContain('Label: in.Label,')
+  })
+
+  test('a `/ 0` operand declines collision-derivation — Go constant division by zero is a compile error', () => {
+    const result = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function C(props: { count?: number }) {
+  const [count, setCount] = createSignal((props.count ?? 1) / 0)
+  return <span>{count()}</span>
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    const types = result.files.find(f => f.type === 'types')!.content
+    const newProps = types.slice(types.indexOf('func NewCProps'))
+    expect(newProps).not.toContain('count / 0')
+    expect(newProps).toContain('Count: in.Count,')
+  })
+
+  test('the same collision reached through a component-scope const hop (#2685) lowers identically', () => {
+    const direct = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function Direct(props: { count?: number }) {
+  const [count, setCount] = createSignal((props.count ?? 1) * 2)
+  return <span>{count()}</span>
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    const viaConst = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function ViaConst(props: { count?: number }) {
+  const mid = props.count
+  const [count, setCount] = createSignal((mid ?? 1) * 2)
+  return <span>{count()}</span>
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    const directTypes = direct.files.find(f => f.type === 'types')!.content
+    const viaConstTypes = viaConst.files.find(f => f.type === 'types')!.content
+    expect(directTypes.slice(directTypes.indexOf('func NewDirectProps'))).toContain('Count: count * 2,')
+    expect(viaConstTypes.slice(viaConstTypes.indexOf('func NewViaConstProps'))).toContain('Count: count * 2,')
+  })
+
+  test('a differently-named signal deriving from the same prop (no collision) is untouched — its own field, not the shared one', () => {
+    const result = compileJSX(`
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function NonCollide(props: { count?: number }) {
+  const [doubled, setDoubled] = createSignal((props.count ?? 1) * 2)
+  return <span>{doubled()}</span>
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter(), outputIR: false })
+    const types = result.files.find(f => f.type === 'types')!.content
+    // No collision here — `count`'s own field stays the plain concrete type,
+    // byte-identical to before this fix.
+    expect(types).toContain('Count int')
+    expect(types).not.toContain('Count interface{}')
+    const newProps = types.slice(types.indexOf('func NewNonCollideProps'))
+    expect(newProps).not.toContain('var count int')
+    expect(newProps).toContain('Count: in.Count,')
+  })
+})
+
 // #2228: a `.filter(t => …).map(todo => <Child todo={todo} .../>)` loop whose
 // body is a single child component ranges the WRAPPER slice (`.TodoItems`,
 // `.{ChildName}s` — see #2130 above), so `{{if}}`'s dot context for the
@@ -5948,9 +6221,11 @@ export { TaggedList }
     expect(types).toContain('Title string `json:"title"`')
     expect(types).toContain('Tags []string `json:"tags"`')
     // The Input/Props field is a typed struct slice, not the old
-    // `[]map[string]interface{}` fallback.
+    // `[]map[string]interface{}` fallback. Scoped to the field itself —
+    // `BfCallerProps map[string]interface{}` (#2684) legitimately appears
+    // elsewhere in every generated Props struct now.
     expect(types).toMatch(/Items \[\]TaggedListItemsItem/)
-    expect(types).not.toContain('map[string]interface{}')
+    expect(types).not.toMatch(/Items \[?\]?map\[string\]interface\{\}/)
   })
 
   test('nested anonymous property inside a NAMED type synthesizes a named struct (case ii, Row.user)', () => {
@@ -5984,7 +6259,10 @@ export function NestedNames() {
     // The signal's inline initial value bakes through the STRUCT literal
     // path, not `bakeInlineObjectAsGoMap`'s capitalized-key map convention.
     expect(types).toContain('Row{ID: "r1", User: RowUser{Name: "Ada"}}')
-    expect(types).not.toContain('map[string]interface{}')
+    // Scoped to the `User` field itself — `BfCallerProps
+    // map[string]interface{}` (#2684) legitimately appears elsewhere in
+    // every generated Props struct now.
+    expect(types).not.toMatch(/User map\[string\]interface\{\}/)
   })
 
   test('a synthesized-name collision gracefully falls back to the pre-#2674 map convention, not a regression', () => {
@@ -6045,7 +6323,15 @@ export { TaggedList }
     expect(payload).toEqual({ items: [{ title: 'Alpha', tags: ['a', 'b'] }] })
   })
 
-  test('real go-run render: bf-p carries camelCase keys for a nested anonymous object inside a named type (case ii)', async () => {
+  test('real go-run render: a signal-backed nested anonymous object is baked into SSR HTML but excluded from bf-p (#2672)', async () => {
+    // `rows` here is a SIGNAL, not a prop — `NestedNames` takes no props at
+    // all. Its data still resolves the synthesized-struct-type branch of
+    // `emitPropsDataFields` (the case ii struct-synthesis this describe
+    // block exists to cover), so this doubles as a real-go-run confirmation
+    // that branch's json tag is also `-` now, not just the general one.
+    // `{{.Field}}` SSR access is unaffected by json tags — the rendered
+    // `<li>Ada</li>` still bakes correctly; only `bf-p` (component-internal
+    // signal state, not caller input) drops the redundant `rows` key.
     const source = `
 "use client"
 import { createSignal } from "@barefootjs/client"
@@ -6063,12 +6349,63 @@ export function NestedNames() {
       if (err instanceof GoNotAvailableError) return // Go toolchain not installed on this host
       throw err
     }
+    // SSR HTML still bakes the signal's initial data — unaffected by the
+    // json tag, since `{{.Field}}` template access doesn't consult it.
+    expect(html).toContain('<li')
+    expect(html).toContain('Ada')
     const bfPMatch = html.match(/bf-p="([^"]*)"/)
     expect(bfPMatch).not.toBeNull()
     const decoded = bfPMatch![1]
       .replace(/&#34;/g, '"')
       .replace(/&quot;/g, '"')
     const payload = JSON.parse(decoded)
-    expect(payload).toEqual({ rows: [{ id: 'r1', user: { name: 'Ada' } }] })
+    // No props at all on this component — bf-p carries nothing. Still a
+    // real, present `bf-p="{}"` (#2684's sidecar substitution isn't gated
+    // on emptiness — see `BfPropsAttr`'s doc comment for why).
+    expect(payload).toEqual({})
+  })
+
+  // #2684 end-to-end: an omitted optional prop must not resurrect the
+  // author's default, or a `null`, in the wire payload — and an EXPLICIT
+  // falsy/zero value the caller DID pass must still come through.
+  test('real go-run render: bf-p carries only caller-supplied keys — omitted optional absent, explicit zero present, required always present', async () => {
+    const source = `
+'use client'
+import { createSignal } from '@barefootjs/client'
+export function C(props: { x?: number; label?: string; name: string }) {
+  const [x] = createSignal(props.x ?? 7)
+  return <div data-name={props.name}>{x()}</div>
+}
+export { C }
+`
+    let htmlOmitted: string
+    let htmlExplicitZero: string
+    try {
+      htmlOmitted = await renderGoTemplateComponent({
+        source,
+        adapter: new GoTemplateAdapter(),
+        props: { name: 'Ada' },
+      })
+      htmlExplicitZero = await renderGoTemplateComponent({
+        source,
+        adapter: new GoTemplateAdapter(),
+        props: { name: 'Ada', x: 0 },
+      })
+    } catch (err) {
+      if (err instanceof GoNotAvailableError) return // Go toolchain not installed on this host
+      throw err
+    }
+    const decode = (html: string) => {
+      const m = html.match(/bf-p="([^"]*)"/)
+      expect(m).not.toBeNull()
+      return JSON.parse(m![1].replace(/&#34;/g, '"').replace(/&quot;/g, '"'))
+    }
+    // `x` omitted: no baked `7`, no `null` — the key is simply absent.
+    // `label` (class-3 residual, no consumption anywhere) still shows up at
+    // its Go zero value — documented, not silently dropped.
+    expect(decode(htmlOmitted)).toEqual({ name: 'Ada', label: '' })
+    // `x: 0` explicitly passed: present with the caller's real value, not
+    // coalesced away or confused with "absent".
+    expect(decode(htmlExplicitZero)).toEqual({ name: 'Ada', label: '', x: 0 })
   })
 })

package/src/adapter/emit-context.ts

@@ -59,6 +59,20 @@ export interface GoEmitContext {
     preParsed?: ParsedExpr,
   ): { propName: string; goFallback: string } | null
 
+  /**
+   * #2683: match the collision-derivation shape `(props.X ?? <lit>) <op>
+   * <int>` against an already-resolved `ParsedExpr` — the ONE non-idempotent
+   * form this adapter faithfully lowers when a signal's Go field name
+   * collides with its own prop's field. Composes
+   * {@link extractPropFallback}'s structural presence-check recognition
+   * (applied to the embedded `??` subtree) with the same non-negative-
+   * integer arithmetic wrap the memo-computation emitter already supports
+   * for a bare `props.X <op> N`. Returns null for any other shape.
+   */
+  extractCollisionDerivation(
+    parsed: ParsedExpr | undefined,
+  ): { propName: string; goFallback: string; operator: string; operand: string } | null
+
   /**
    * Inline a module string const by name as a Go double-quoted literal
    * (`"<escaped>"`), or null when the name is not such a const (loop vars and