@barefootjs/go-template 0.5.3 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/go-template",
-  "version": "0.5.3",
+  "version": "0.6.1",
   "description": "Go html/template adapter for BarefootJS - generates Go template files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -54,6 +54,6 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.5.3"
+    "@barefootjs/jsx": "0.6.1"
   }
 }

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

@@ -2182,11 +2182,26 @@ import { fixture as arrayLastIndexOfFixture } from '../../../adapter-tests/fixtu
 import { fixture as arrayAtFixture } from '../../../adapter-tests/fixtures/methods/array-at'
 import { fixture as arrayConcatFixture } from '../../../adapter-tests/fixtures/methods/array-concat'
 import { fixture as arraySliceFixture } from '../../../adapter-tests/fixtures/methods/array-slice'
+import { fixture as arraySliceCopyFixture } from '../../../adapter-tests/fixtures/methods/array-slice-copy'
+import { fixture as arrayJoinDefaultFixture } from '../../../adapter-tests/fixtures/methods/array-join-default'
+import { fixture as arrayAtDefaultFixture } from '../../../adapter-tests/fixtures/methods/array-at-default'
+import { fixture as arrayConcatCopyFixture } from '../../../adapter-tests/fixtures/methods/array-concat-copy'
 import { fixture as arrayReverseFixture } from '../../../adapter-tests/fixtures/methods/array-reverse'
 import { fixture as arrayToReversedFixture } from '../../../adapter-tests/fixtures/methods/array-toReversed'
 import { fixture as stringToLowerCaseFixture } from '../../../adapter-tests/fixtures/methods/string-toLowerCase'
 import { fixture as stringToUpperCaseFixture } from '../../../adapter-tests/fixtures/methods/string-toUpperCase'
 import { fixture as stringTrimFixture } from '../../../adapter-tests/fixtures/methods/string-trim'
+// #1448 Tier B — string methods.
+import { fixture as stringSplitFixture } from '../../../adapter-tests/fixtures/methods/string-split'
+import { fixture as stringSplitLimitFixture } from '../../../adapter-tests/fixtures/methods/string-split-limit'
+import { fixture as stringStartsWithFixture } from '../../../adapter-tests/fixtures/methods/string-startsWith'
+import { fixture as stringStartsWithPositionFixture } from '../../../adapter-tests/fixtures/methods/string-startsWith-position'
+import { fixture as stringEndsWithFixture } from '../../../adapter-tests/fixtures/methods/string-endsWith'
+import { fixture as stringEndsWithPositionFixture } from '../../../adapter-tests/fixtures/methods/string-endsWith-position'
+import { fixture as stringReplaceFixture } from '../../../adapter-tests/fixtures/methods/string-replace'
+import { fixture as stringRepeatFixture } from '../../../adapter-tests/fixtures/methods/string-repeat'
+import { fixture as stringPadStartFixture } from '../../../adapter-tests/fixtures/methods/string-padStart'
+import { fixture as stringPadEndFixture } from '../../../adapter-tests/fixtures/methods/string-padEnd'
 // #1448 Tier B — .sort / .toSorted fixtures.
 import { fixture as arraySortFieldAscFixture } from '../../../adapter-tests/fixtures/methods/array-sort-field-asc'
 import { fixture as arraySortFieldDescFixture } from '../../../adapter-tests/fixtures/methods/array-sort-field-desc'
@@ -2214,6 +2229,13 @@ describe('GoTemplateAdapter - #1448 Tier A/B fixture-driven lowering pins', () =
     { fixture: arrayAtFixture,          expect: 'bf_at .Items (bf_neg 1)' },
     { fixture: arrayConcatFixture,      expect: 'bf_concat .Left .Right' },
     { fixture: arraySliceFixture,       expect: 'bf_slice .Items 1 3' },
+    // #1448 full-arity — zero-arg defaults. `.slice()` → start 0 (full
+    // copy); `.join()` → default `,` separator.
+    { fixture: arraySliceCopyFixture,   expect: 'bf_slice .Items 0' },
+    { fixture: arrayJoinDefaultFixture, expect: 'bf_join (.Items) ","' },
+    // `.at()` → index 0; `.concat()` → the receiver (shallow copy).
+    { fixture: arrayAtDefaultFixture,   expect: 'bf_at .Items 0' },
+    { fixture: arrayConcatCopyFixture,  expect: 'bf_join (.Items) "|"' },
     { fixture: arrayReverseFixture,     expect: 'bf_reverse .Items' },
     // .toReversed shares the helper with .reverse — pinning both
     // routings catches a future divergence between them.
@@ -2221,6 +2243,24 @@ describe('GoTemplateAdapter - #1448 Tier A/B fixture-driven lowering pins', () =
     { fixture: stringToLowerCaseFixture,expect: 'bf_lower .Value' },
     { fixture: stringToUpperCaseFixture,expect: 'bf_upper .Value' },
     { fixture: stringTrimFixture,       expect: 'bf_trim .Value' },
+    // #1448 Tier B — string → array. `.split(',')` lowers to
+    // `bf_split`, here chained into `.join('|')` so the slice is
+    // observable (`bf_join (bf_split .Value ",") "|"`).
+    { fixture: stringSplitFixture,      expect: 'bf_split .Value ","' },
+    { fixture: stringSplitLimitFixture, expect: 'bf_split .Value "," 2' },
+    // #1448 Tier B — string → boolean at condition position, so the
+    // emit lands inside `{{if ...}}`.
+    { fixture: stringStartsWithFixture, expect: '{{if bf_starts_with .Value .Prefix}}' },
+    { fixture: stringStartsWithPositionFixture, expect: '{{if bf_starts_with .Value "world" 6}}' },
+    { fixture: stringEndsWithFixture,   expect: '{{if bf_ends_with .Value .Suffix}}' },
+    { fixture: stringEndsWithPositionFixture,   expect: '{{if bf_ends_with .Value "hello" 5}}' },
+    // #1448 Tier B — string → string, first-occurrence replace.
+    { fixture: stringReplaceFixture,    expect: 'bf_replace .Value "o" "0"' },
+    // #1448 Tier B — string → string, repeat n times.
+    { fixture: stringRepeatFixture,     expect: 'bf_repeat .Value 3' },
+    // #1448 Tier B — string → string, padded to a target width.
+    { fixture: stringPadStartFixture,   expect: 'bf_pad_start .Value 5 "0"' },
+    { fixture: stringPadEndFixture,     expect: 'bf_pad_end .Value 5 "."' },
     // #1448 Tier B — sort / toSorted. Loop-chained shapes wrap the
     // iterable in `bf_sort .Items <kind> <key> <type> <dir>`;
     // standalone shapes inline the helper at the call site.
@@ -2278,6 +2318,81 @@ describe('GoTemplateAdapter - #1448 Tier A/B fixture-driven lowering pins', () =
 // now listed in `UNSUPPORTED_METHODS`, so `isSupported` refuses them
 // and `convertExpressionToGo` records BF101 — the same treatment the
 // unsupported array methods already got. These tests pin that parity.
+describe('GoTemplateAdapter - #1448 Tier C reduce field capitalisation', () => {
+  // #1728 review: `bf_reduce`'s projected field name must use the same
+  // initialism-aware capitalisation the adapter applies when generating
+  // struct fields (`capitalizeFieldName`), or the runtime reflect lookup
+  // misses the exported field (`id` → struct `ID`, not `Id`) and folds a
+  // zero value. Pin the emitted key so a regression to plain
+  // first-letter capitalisation fails here.
+  test('reduce over an initialism field emits the Go-initialism key (ID, not Id)', () => {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+function C({ items }: { items: { id: number }[] }) {
+  return <div>{items.reduce((sum, x) => sum + x.id, 0)}</div>
+}
+export { C }
+`, adapter)
+    const template = adapter.generate(ir).template ?? ''
+    expect(template).toContain('bf_reduce .Items "+" "field" "ID" "numeric" "0"')
+    expect(template).not.toContain('"Id"')
+  })
+})
+
+describe('GoTemplateAdapter - #1448 Tier C .flat(depth?)', () => {
+  function emitFlat(expr: string): string {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+function C({ rows }: { rows: number[][] }) {
+  return <div>{${expr}}</div>
+}
+export { C }
+`, adapter)
+    return adapter.generate(ir).template ?? ''
+  }
+
+  test('.flat() emits bf_flat with default depth 1', () => {
+    expect(emitFlat('rows.flat()')).toContain('bf_flat .Rows 1')
+  })
+
+  test('.flat(2) emits the explicit depth', () => {
+    expect(emitFlat('rows.flat(2)')).toContain('bf_flat .Rows 2')
+  })
+
+  test('.flat(Infinity) emits the -1 full-depth sentinel', () => {
+    expect(emitFlat('rows.flat(Infinity)')).toContain('bf_flat .Rows -1')
+  })
+})
+
+describe('GoTemplateAdapter - #1448 Tier C .flatMap(field projection)', () => {
+  function emitFlatMap(expr: string): string {
+    const adapter = new GoTemplateAdapter()
+    const ir = compileToIR(`
+function C({ rows }: { rows: { a: string; b: string; tags: string[] }[] }) {
+  return <div>{${expr}}</div>
+}
+export { C }
+`, adapter)
+    return adapter.generate(ir).template ?? ''
+  }
+
+  test('.flatMap(i => i.field) emits bf_flat_map with the Go-capitalised field', () => {
+    expect(emitFlatMap('rows.flatMap(i => i.tags).join(" ")')).toContain('bf_flat_map .Rows "field" "Tags"')
+  })
+
+  test('.flatMap(i => i) emits the self projection', () => {
+    expect(emitFlatMap('rows.flatMap(i => i).join(" ")')).toContain('bf_flat_map .Rows "self" ""')
+  })
+
+  test('.flatMap(i => [i.a, i.b]) emits bf_flat_map_tuple with capitalised leaves', () => {
+    expect(emitFlatMap('rows.flatMap(i => [i.a, i.b]).join(" ")')).toContain('bf_flat_map_tuple .Rows "field" "A" "field" "B"')
+  })
+
+  test('tuple self + field leaves', () => {
+    expect(emitFlatMap('rows.flatMap(i => [i, i.a]).join(" ")')).toContain('bf_flat_map_tuple .Rows "self" "" "field" "A"')
+  })
+})
+
 describe('GoTemplateAdapter - #1448 @client escape hatch (unsupported methods)', () => {
   // Compile a single expression placed in `<div>` text position, with
   // and without the directive, and return both the build errors and
@@ -2323,19 +2438,30 @@ export function C() {
   // Go fragment that must NOT survive into the template (the pre-fix
   // silent-footgun output for the string rows).
   const unsupported: Array<{ name: string; expr: string; badEmit: string }> = [
-    // Tier C array methods.
-    { name: 'reduce', expr: `items().reduce((a, b) => a + b.n, 0)`, badEmit: '.Reduce' },
-    { name: 'flatMap', expr: `items().flatMap(i => i.tags)`, badEmit: '.FlatMap' },
-    { name: 'flat', expr: `items().flat()`, badEmit: '.Flat' },
+    // Tier C array methods. The arithmetic-fold `.reduce(fn, init)`
+    // catalogue now lowers (pinned in the positive reduce-* fixtures);
+    // the no-initial-value form stays refused — JS throws on an empty
+    // array there, which a template can't mirror.
+    { name: 'reduce (no init)', expr: `items().reduce((a, b) => a + b.n)`, badEmit: '.Reduce' },
+    // Self / field / field-tuple `.flatMap` now lowers (#1448 Tier C); a
+    // tuple with a non-leaf element (here a string literal) stays refused.
+    { name: 'flatMap (literal element)', expr: `items().flatMap(i => [i.name, "x"])`, badEmit: '.FlatMap' },
+    // Lowered methods whose MEANINGFUL extra argument isn't lowered yet
+    // (#1448): the `fromIndex` of `.includes`/`.indexOf`/`.lastIndexOf`
+    // and the variadic `.concat`. The parser refuses these (silently
+    // dropping the arg would change the result) rather than emitting a
+    // render-crashing `.Includes` / `.Concat` field access. (The
+    // zero-arg defaults `.join()`/`.slice()` and JS-ignored trailing
+    // args like `.trim(1)` are accepted — pinned in the positive blocks.)
+    { name: 'includes (2-arg fromIndex)', expr: `items().includes("a", 1)`, badEmit: '.Includes' },
+    { name: 'concat (variadic)', expr: `items().concat(items(), items())`, badEmit: '.Concat' },
     // Tier B/C string methods — previously slipped through with no
-    // diagnostic; now gated by `UNSUPPORTED_METHODS`.
-    { name: 'split', expr: `name().split(",")`, badEmit: '.Name.Split' },
-    { name: 'startsWith', expr: `name().startsWith("a")`, badEmit: '.Name.StartsWith' },
-    { name: 'endsWith', expr: `name().endsWith("z")`, badEmit: '.Name.EndsWith' },
-    { name: 'replace', expr: `name().replace("a", "b")`, badEmit: '.Name.Replace' },
-    { name: 'repeat', expr: `name().repeat(3)`, badEmit: '.Name.Repeat' },
-    { name: 'padStart', expr: `name().padStart(5, "0")`, badEmit: '.Name.PadStart' },
-    { name: 'padEnd', expr: `name().padEnd(5, "0")`, badEmit: '.Name.PadEnd' },
+    // diagnostic; now gated by `UNSUPPORTED_METHODS`. The full Tier B
+    // string set (`split`, `startsWith`, `endsWith`, `replace`,
+    // `repeat`, `padStart`, `padEnd`) has since landed its full-arity
+    // lowering and moved to the positive fixture-pin block above. The
+    // regex-pattern `replace` form is pinned separately below; `charAt`
+    // is Tier C and stays refused entirely.
     { name: 'charAt', expr: `name().charAt(0)`, badEmit: '.Name.CharAt' },
   ]
   for (const { name, expr, badEmit } of unsupported) {
@@ -2354,23 +2480,76 @@ export function C() {
     })
   }
 
+  // The diagnostic's `suggestion.message` is shaped by `isSupported`'s
+  // `selfContained` flag: reasons that already spell out the fix are shown
+  // as-is, while low-level parser reasons still get the adapter's generic
+  // "Options" remediation appended so users never lose actionable steps.
+  function suggestionFor(expr: string): string {
+    const { errors } = emit(expr, false)
+    const e = errors.find(e => e.code === 'BF101' || e.code === 'BF102')
+    return e?.suggestion?.message ?? ''
+  }
+
+  test('self-contained reason is shown without the generic Options block', () => {
+    // Generic unsupported-method reason already carries the remedy.
+    const msg = suggestionFor('items().reduce((a, b) => a + b.n)')
+    expect(msg).toContain('no SSR')
+    expect(msg).not.toContain('Options:')
+  })
+
+  test('tailored forEach reason keeps its own guidance, no Options block', () => {
+    const msg = suggestionFor('items().forEach(x => x)')
+    expect(msg).toContain("'.map(")
+    // The forEach message deliberately steers away from @client; the
+    // generic Options block (which re-suggests it) must not be appended.
+    expect(msg).not.toContain('Options:')
+    expect(msg).not.toContain('@client')
+  })
+
+  test('low-level reason still gets the actionable Options block appended', () => {
+    // `typeof` has no structured remedy reason → users must keep the
+    // generic next steps (regression guard for #1730 review).
+    const msg = suggestionFor('typeof items()')
+    expect(msg).toContain('Options:')
+    expect(msg).toContain('@client')
+  })
+
   // Predicate-level use of an unsupported string method also fails the
-  // build loudly (intended): a `.filter(t => t.name.startsWith("a"))`
+  // build loudly (intended): a `.filter(t => t.name.charAt(0) === "a")`
   // whose predicate calls one of the gated methods now refuses the whole
   // loop with BF101 (via the shared `isSupported` predicate gate in
-  // jsx-to-ir) rather than lowering to a broken `.StartsWith` inside the
+  // jsx-to-ir) rather than lowering to a broken `.CharAt` inside the
   // range. Pinning this so the loud-failure contract can't silently
-  // regress back to the old emit-broken-template behaviour.
+  // regress back to the old emit-broken-template behaviour. (`charAt`
+  // is a Tier C method that stays refused — earlier this test used
+  // `startsWith`, which has since landed its Tier B lowering.)
   test('unsupported string method inside a .filter() predicate raises BF101', () => {
     const result = compileJSX(`
 "use client"
 import { createSignal } from "@barefootjs/client"
 export function C() {
   const [items, setItems] = createSignal<{ name: string }[]>([])
-  return <ul>{items().filter(t => t.name.startsWith("a")).map(t => <li key={t.name}>{t.name}</li>)}</ul>
+  return <ul>{items().filter(t => t.name.charAt(0) === "a").map(t => <li key={t.name}>{t.name}</li>)}</ul>
+}
+`.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter() })
+    expect(result.errors?.some(e => e.code === 'BF101')).toBe(true)
+  })
+
+  // The string-pattern form of `.replace` lowers (#1448 Tier B), but
+  // the regex-pattern form stays refused with BF101 — the Perl `s///`
+  // vs Go `regexp.ReplaceAllString` flavour gap is the open design
+  // question. Pinning the refusal so the string-form lowering can't
+  // accidentally start emitting a broken `.Replace` for the regex form.
+  test('regex-pattern .replace raises BF101 (string-pattern form is lowered)', () => {
+    const result = compileJSX(`
+function C({ value }: { value: string }) {
+  return <div>{value.replace(/o/g, "0")}</div>
 }
+export { C }
 `.trimStart(), 'test.tsx', { adapter: new GoTemplateAdapter() })
     expect(result.errors?.some(e => e.code === 'BF101')).toBe(true)
+    const template = result.files?.find(f => f.path.endsWith('.tmpl'))?.content ?? ''
+    expect(template).not.toContain('.Replace')
   })
 
   // Tier B `.sort` / `.toSorted` follow-ups still refused with BF021.
@@ -2404,7 +2583,9 @@ export function C() {
   // more `can't evaluate field …` crash), so we assert the build error
   // rather than a render crash. Skipped on hosts without Go.
   test('e2e: @client renders placeholder; bare is caught at build with BF101', async () => {
-    const bare = emit(`name().repeat(3)`, false)
+    // Uses the Tier C `charAt` (still refused) — earlier this test used
+    // `repeat`, which has since landed its #1448 Tier B lowering.
+    const bare = emit(`name().charAt(0)`, false)
     expect(bare.errors.some(e => e.code === 'BF101')).toBe(true)
 
     try {
@@ -2414,7 +2595,7 @@ export function C() {
 import { createSignal } from "@barefootjs/client"
 export function C() {
   const [name, setName] = createSignal("hello")
-  return <div>{/* @client */ name().repeat(3)}</div>
+  return <div>{/* @client */ name().charAt(0)}</div>
 }
 `.trimStart(),
         adapter: new GoTemplateAdapter(),

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

@@ -27,6 +27,9 @@ import type {
   ParsedExpr,
   ParsedStatement,
   SortComparator,
+  ReduceOp,
+  FlatDepth,
+  FlatMapOp,
   TemplatePart,
   IRIfStatement,
   IRProvider,
@@ -45,6 +48,7 @@ import {
   type IRNodeEmitter,
   type EmitIRNode,
   type AttrValueEmitter,
+  type SupportResult,
   isBooleanAttr,
   parseExpression,
   isSupported,
@@ -208,8 +212,56 @@ function emitBfSort(recv: string, c: SortComparator): string {
   return `bf_sort ${wrapIfMultiToken(recv)} ${groups.join(' ')}`
 }
 
+/**
+ * Emit the `bf_reduce` call for a `.reduce(fn, init)` arithmetic fold
+ * (#1448 Tier C):
+ *
+ *   bf_reduce <recv> "<op>" "<keyKind>" "<keyName>" "<type>" "<init>" "<direction>"
+ *
+ *   op:        "+" | "*"
+ *   keyKind:   "self" | "field"
+ *   keyName:   "" when keyKind=self; capitalised field name otherwise
+ *              (matches the Go struct-field convention, mirroring
+ *              `emitBfSort`)
+ *   type:      "numeric" | "string"
+ *   init:      the fold's start value — the numeric literal's text for a
+ *              numeric fold, or the string literal's contents for a
+ *              concat fold
+ *   direction: "left" (reduce) | "right" (reduceRight)
+ *
+ * The runtime folds `init <op> key(item)` in `direction` order and
+ * returns the accumulated value (float64 for numeric, string for
+ * concat). The order is only observable for string concat — numeric
+ * sum / product commute.
+ */
+function emitBfReduce(recv: string, op: ReduceOp, direction: 'left' | 'right'): string {
+  const keyName = op.key.kind === 'field' ? capitalize(op.key.field) : ''
+  // `op.init` is already the decoded seed value (canonical decimal for
+  // numeric folds — `strconv.ParseFloat`-safe; escape-free contents for
+  // concat folds). Pass it as a quoted operand the runtime interprets
+  // by `type`. `direction` is "left" (reduce) or "right" (reduceRight)
+  // — only observable for string concatenation; numeric folds are
+  // commutative.
+  return `bf_reduce ${wrapIfMultiToken(recv)} "${op.op}" "${op.key.kind}" "${keyName}" "${op.type}" "${escapeGoString(op.init)}" "${direction}"`
+}
+
+/** Escape a value for embedding in a Go-template double-quoted string. */
+function escapeGoString(s: string): string {
+  return s.replace(/\\/g, '\\\\').replace(/"/g, '\\"')
+}
+
 function capitalize(s: string): string {
-  return s.length === 0 ? s : s[0].toUpperCase() + s.slice(1)
+  if (s.length === 0) return s
+  // Match the adapter's struct-field naming (`capitalizeFieldName`):
+  // a whole-word Go initialism uppercases entirely (`id` → `ID`,
+  // `url` → `URL`) so the `bf_sort` / `bf_reduce` reflect lookup
+  // resolves the generated exported field instead of silently folding
+  // a zero value. The class is fully initialised by the time any emit
+  // helper runs, so referencing the static set here is safe.
+  if (GoTemplateAdapter.GO_INITIALISMS.has(s.toLowerCase())) {
+    return s.toUpperCase()
+  }
+  return s[0].toUpperCase() + s.slice(1)
 }
 
 /**
@@ -239,6 +291,22 @@ interface PrimitiveSpec {
   emit: (args: string[]) => string
 }
 
+// Generic remediation appended to BF101 / BF102 diagnostics whose reason
+// doesn't already carry actionable next steps.
+const GO_REMEDIATION_OPTIONS =
+  'Options:\n1. Use @client directive for client-side evaluation\n2. Pre-compute the value in Go code'
+
+// Build the `suggestion.message` for an unsupported expression/condition.
+// A self-contained reason (it already spells out the fix — e.g. the
+// pre-compute / @client hint or the tailored forEach message) is shown
+// as-is; a low-level reason gets the generic options appended; with no
+// reason at all we fall back to the options alone.
+function buildUnsupportedSuggestion(support: SupportResult): string {
+  if (!support.reason) return GO_REMEDIATION_OPTIONS
+  if (support.selfContained) return support.reason
+  return `${support.reason}\n\n${GO_REMEDIATION_OPTIONS}`
+}
+
 const GO_TEMPLATE_PRIMITIVES: Record<string, PrimitiveSpec> = {
   'JSON.stringify': { arity: 1, emit: (args) => `bf_json ${args[0]}` },
   'String':         { arity: 1, emit: (args) => `bf_string ${args[0]}` },
@@ -2579,7 +2647,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
   private static GO_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/
 
   /** Go common initialisms that should be fully uppercased (https://go.dev/wiki/CodeReviewComments#initialisms) */
-  private static GO_INITIALISMS = new Set([
+  // Not `private`: the module-level `capitalize` helper reads this so
+  // `bf_sort` / `bf_reduce` field projection matches `capitalizeFieldName`.
+  static GO_INITIALISMS = new Set([
     'id', 'url', 'http', 'https', 'api', 'json', 'xml', 'html', 'css', 'sql',
     'ip', 'tcp', 'udp', 'dns', 'ssh', 'tls', 'ssl', 'uri', 'uid', 'uuid',
     'ascii', 'utf8', 'eof', 'grpc', 'rpc', 'cpu', 'gpu', 'ram', 'os',
@@ -3089,7 +3159,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
       message: `Higher-order method '.${method}' shape cannot be lowered to a Go template action`,
       loc: this.makeLoc(),
       suggestion: {
-        message: 'Options:\n1. Use @client directive for client-side evaluation\n2. Pre-compute the value in Go code',
+        message: GO_REMEDIATION_OPTIONS,
       },
     })
     return `""`
@@ -3109,7 +3179,9 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     switch (method) {
       case 'join': {
         const obj = emit(object)
-        const sep = emit(args[0])
+        // `.join()` defaults the separator to `,` (JS); any extra
+        // argument is ignored. Only `args[0]` is read.
+        const sep = args.length >= 1 ? emit(args[0]) : '","'
         // Both operands need paren-wrapping when they emit a
         // multi-token prefix-call form (e.g. `sep` lowering to
         // `bf_trim .Raw` would make Go template parse
@@ -3145,30 +3217,36 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         // `.at(i)` supports negative indices (`.at(-1)` → last
         // element). The Go `bf_at` helper was already registered in
         // the FuncMap for the runtime — this PR wires it to the JS
-        // method name at the adapter layer.
+        // method name at the adapter layer. `.at()` with no argument is
+        // `.at(0)` (the first element); extra arguments are ignored.
         const obj = emit(object)
-        const idx = emit(args[0])
+        const idx = args.length >= 1 ? emit(args[0]) : '0'
         return `bf_at ${wrapIfMultiToken(obj)} ${wrapIfMultiToken(idx)}`
       }
       case 'concat': {
         // `.concat(other)` merges two arrays. The runtime helper
         // `bf_concat` reflects over both operands so callers can
         // mix `[]string` + `[]string` or `[]any` + `[]string` etc.
-        // without per-call-site type-juggling.
+        // without per-call-site type-juggling. `.concat()` with no
+        // argument is a shallow copy — indistinguishable from the
+        // receiver in an SSR snapshot, so it lowers to the receiver.
+        if (args.length === 0) {
+          return emit(object)
+        }
         const a = emit(object)
         const b = emit(args[0])
         return `bf_concat ${wrapIfMultiToken(a)} ${wrapIfMultiToken(b)}`
       }
       case 'slice': {
-        // `.slice(start)` / `.slice(start, end)` — both forms route
-        // through `bf_slice`. The runtime helper treats a `nil`
-        // `end` (the variadic-arg absence) as "to length", matching
-        // the JS semantic. Out-of-bounds indices clamp instead of
-        // panicking (also JS-compat); same with `start > end`
-        // returning an empty slice.
+        // `.slice()` / `.slice(start)` / `.slice(start, end)` — route
+        // through `bf_slice`. A missing `start` defaults to 0 (full
+        // copy); the runtime helper treats an absent `end` as "to
+        // length". Out-of-bounds indices clamp instead of panicking
+        // (JS-compat); `start > end` returns an empty slice. JS ignores
+        // a third+ argument, so only `args[0]` / `args[1]` are read.
         const recv = emit(object)
-        const start = emit(args[0])
-        if (args.length === 1) {
+        const start = args.length >= 1 ? emit(args[0]) : '0'
+        if (args.length <= 1) {
           return `bf_slice ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(start)}`
         }
         const end = emit(args[1])
@@ -3204,6 +3282,78 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         const recv = emit(object)
         return `bf_trim ${wrapIfMultiToken(recv)}`
       }
+      case 'split': {
+        // `.split()` / `.split(sep)` / `.split(sep, limit)` — string →
+        // `[]any`. No separator → the whole string as a single element
+        // (`bf_arr`). Otherwise `bf_split` (wraps `strings.Split`,
+        // normalised to `[]any`); a second `limit` argument caps the
+        // pieces. JS ignores a third+ argument. See #1448 Tier B.
+        const recv = emit(object)
+        if (args.length === 0) {
+          return `bf_arr ${wrapIfMultiToken(recv)}`
+        }
+        const sep = emit(args[0])
+        if (args.length === 1) {
+          return `bf_split ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(sep)}`
+        }
+        const limit = emit(args[1])
+        return `bf_split ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(sep)} ${wrapIfMultiToken(limit)}`
+      }
+      case 'startsWith':
+      case 'endsWith': {
+        // `.startsWith(prefix, position?)` / `.endsWith(suffix,
+        // endPosition?)` — string → boolean via the `bf_starts_with` /
+        // `bf_ends_with` helpers (`strings.HasPrefix` /
+        // `strings.HasSuffix`). The optional second argument re-anchors
+        // the test; JS ignores a third+ argument. See #1448 Tier B.
+        const fn = method === 'startsWith' ? 'bf_starts_with' : 'bf_ends_with'
+        const recv = emit(object)
+        const arg = emit(args[0])
+        const base = `${fn} ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(arg)}`
+        if (args.length >= 2) {
+          return `${base} ${wrapIfMultiToken(emit(args[1]))}`
+        }
+        return base
+      }
+      case 'replace': {
+        // `.replace(old, new)` — string-pattern form, first occurrence
+        // only, via the new `bf_replace` helper (`strings.Replace` with
+        // n=1). The regex-pattern form is refused upstream at the
+        // parser. See #1448 Tier B.
+        const recv = emit(object)
+        const oldS = emit(args[0])
+        const newS = emit(args[1])
+        return `bf_replace ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(oldS)} ${wrapIfMultiToken(newS)}`
+      }
+      case 'repeat': {
+        // `.repeat(n)` — string repeated `n` times via the `bf_repeat`
+        // helper. The helper clamps a negative count to "" instead of
+        // letting `strings.Repeat` panic. Full JS arity: the no-argument
+        // form is `repeat(0)` → ""; a second+ argument is ignored.
+        // See #1448 Tier B.
+        const recv = emit(object)
+        const count = args.length === 0 ? '0' : emit(args[0])
+        return `bf_repeat ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(count)}`
+      }
+      case 'padStart':
+      case 'padEnd': {
+        // `.padStart(target, pad?)` / `.padEnd(target, pad?)` — pad to
+        // `target` runes with `pad` (default a single space, supplied
+        // by the variadic helper when the arg is absent). Full JS arity:
+        // the no-argument form is `padStart(0)` → the receiver
+        // unchanged; a third+ argument is ignored. See #1448 Tier B.
+        const fn = method === 'padStart' ? 'bf_pad_start' : 'bf_pad_end'
+        const recv = emit(object)
+        if (args.length === 0) {
+          return `${fn} ${wrapIfMultiToken(recv)} 0`
+        }
+        const target = emit(args[0])
+        if (args.length === 1) {
+          return `${fn} ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(target)}`
+        }
+        const pad = emit(args[1])
+        return `${fn} ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(target)} ${wrapIfMultiToken(pad)}`
+      }
       default: {
         const _exhaustive: never = method
         throw new Error(`Go arrayMethod: unhandled ArrayMethod '${(_exhaustive as string)}'`)
@@ -3231,6 +3381,51 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
     return emitBfSort(emit(object), comparator)
   }
 
+  reduceMethod(
+    method: 'reduce' | 'reduceRight',
+    object: ParsedExpr,
+    reduceOp: ReduceOp,
+    emit: (e: ParsedExpr) => string,
+  ): string {
+    // `.reduce(fn, init)` / `.reduceRight(fn, init)` arithmetic-fold
+    // lowering (#1448 Tier C). The structured `ReduceOp` (op / key /
+    // type / init) plus the fold direction feed the `bf_reduce` runtime
+    // helper, which folds the receiver into a scalar.
+    const direction = method === 'reduceRight' ? 'right' : 'left'
+    return emitBfReduce(emit(object), reduceOp, direction)
+  }
+
+  flatMethod(object: ParsedExpr, depth: FlatDepth, emit: (e: ParsedExpr) => string): string {
+    // `.flat(depth?)` → `bf_flat <recv> <depth>`. The `Infinity` form
+    // lowers to the `-1` sentinel (flatten fully); a finite depth flattens
+    // that many levels (`0` = shallow copy). See packages/adapter-go-
+    // template/runtime/bf.go.
+    const d = depth === 'infinity' ? -1 : depth
+    return `bf_flat ${wrapIfMultiToken(emit(object))} ${d}`
+  }
+
+  flatMapMethod(object: ParsedExpr, op: FlatMapOp, emit: (e: ParsedExpr) => string): string {
+    const recv = wrapIfMultiToken(emit(object))
+    const proj = op.projection
+    // Tuple projection `i => [i.a, i.b]` → `bf_flat_map_tuple <recv>
+    // "<kind>" "<name>" ...` (one quoted pair per leaf). flat(1) removes
+    // only the literal's wrapper, so the runtime appends each leaf verbatim.
+    if (proj.kind === 'tuple') {
+      const pairs = proj.elements
+        .map(l => (l.kind === 'self' ? `"self" ""` : `"field" "${capitalize(l.field)}"`))
+        .join(' ')
+      return `bf_flat_map_tuple ${recv} ${pairs}`
+    }
+    // Scalar `.flatMap(i => i)` / `.flatMap(i => i.field)` → `bf_flat_map
+    // <recv> "<kind>" "<name>"`. The runtime projects each item then
+    // flattens one level. The field name uses the Go struct-field
+    // capitalisation, matching `bf_reduce` / `bf_sort`.
+    if (proj.kind === 'self') {
+      return `bf_flat_map ${recv} "self" ""`
+    }
+    return `bf_flat_map ${recv} "field" "${capitalize(proj.field)}"`
+  }
+
   unsupported(raw: string, _reason: string): string {
     // Should not happen if `isSupported` was checked at parse time.
     return `[UNSUPPORTED: ${raw}]`
@@ -3966,9 +4161,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         message: `Expression not supported: ${trimmed}`,
         loc: this.makeLoc(),
         suggestion: {
-          message: support.reason
-            ? `${support.reason}\n\nOptions:\n1. Use @client directive for client-side evaluation\n2. Pre-compute the value in Go code`
-            : 'Options:\n1. Use @client directive for client-side evaluation\n2. Pre-compute the value in Go code',
+          message: buildUnsupportedSuggestion(support),
         },
       })
       // Return empty string - Go template comments must be separate actions
@@ -4006,7 +4199,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
             message: `Complex predicate in else-if is not supported: ${altIfStmt.condition}`,
             loc: this.makeLoc(),
             suggestion: {
-              message: 'Options:\n1. Use @client directive for client-side evaluation\n2. Pre-compute the value in Go code',
+              message: GO_REMEDIATION_OPTIONS,
             },
           })
         }
@@ -4103,9 +4296,7 @@ export class GoTemplateAdapter extends BaseAdapter implements ParsedExprEmitter,
         message: `Condition not supported: ${trimmed}`,
         loc: this.makeLoc(),
         suggestion: {
-          message: support.reason
-            ? `${support.reason}\n\nOptions:\n1. Use @client directive for client-side evaluation\n2. Pre-compute the value in Go code`
-            : 'Expression contains unsupported syntax',
+          message: buildUnsupportedSuggestion(support),
         },
       })
       // Return false - Go template comments must be separate actions