@barefootjs/jsx 0.5.3 → 0.6.0

package/src/__tests__/expression-parser.test.ts

@@ -398,25 +398,104 @@ describe('expression-parser', () => {
       const result = parseExpression("items().filter(({name = 'anon'}) => name.startsWith('a'))")
       expect(result.kind).toBe('higher-order')
       if (result.kind === 'higher-order') {
-        // Predicate: `(_t.name ?? 'anon').startsWith('a')`.
-        expect(result.predicate.kind).toBe('call')
-        if (result.predicate.kind === 'call') {
-          expect(result.predicate.callee.kind).toBe('member')
-          if (result.predicate.callee.kind === 'member') {
-            expect(result.predicate.callee.property).toBe('startsWith')
-            expect(result.predicate.callee.object.kind).toBe('logical')
-            if (result.predicate.callee.object.kind === 'logical') {
-              expect(result.predicate.callee.object.op).toBe('??')
-              expect(result.predicate.callee.object.right.kind).toBe('literal')
-              if (result.predicate.callee.object.right.kind === 'literal') {
-                expect(result.predicate.callee.object.right.value).toBe('anon')
-              }
+        // Predicate: `(_t.name ?? 'anon').startsWith('a')`. Since #1448
+        // Tier B, `.startsWith` lowers to an `array-method` node (it was
+        // a generic `call` before), so the receiver is on `.object`.
+        expect(result.predicate.kind).toBe('array-method')
+        if (result.predicate.kind === 'array-method') {
+          expect(result.predicate.method).toBe('startsWith')
+          expect(result.predicate.object.kind).toBe('logical')
+          if (result.predicate.object.kind === 'logical') {
+            expect(result.predicate.object.op).toBe('??')
+            expect(result.predicate.object.right.kind).toBe('literal')
+            if (result.predicate.object.right.kind === 'literal') {
+              expect(result.predicate.object.right.value).toBe('anon')
             }
           }
         }
       }
     })
 
+    test('lowers .startsWith(search, position) — full arity (#1448 Tier B)', () => {
+      const result = parseExpression(`name().startsWith("world", 6)`)
+      expect(result.kind).toBe('array-method')
+      if (result.kind === 'array-method') {
+        expect(result.method).toBe('startsWith')
+        // Both the search string and the position survive as args so the
+        // adapter can emit the re-anchored test.
+        expect(result.args.length).toBe(2)
+      }
+    })
+
+    test('refuses .startsWith() with no search string (#1448 Tier B)', () => {
+      // JS coerces the missing argument to the string "undefined" — a
+      // degenerate result not worth lowering (mirrors `.includes()`).
+      const result = parseExpression(`name().startsWith()`)
+      expect(result.kind).toBe('unsupported')
+    })
+
+    test('lowers .replace(pattern, replacement, extra) — ignores 3rd+ arg (#1448 Tier B)', () => {
+      const result = parseExpression(`name().replace("o", "0", "extra")`)
+      expect(result.kind).toBe('array-method')
+      if (result.kind === 'array-method') {
+        expect(result.method).toBe('replace')
+      }
+    })
+
+    test('refuses .replace(pattern) with no replacement (#1448 Tier B)', () => {
+      // JS coerces the missing replacement to the string "undefined".
+      const result = parseExpression(`name().replace("o")`)
+      expect(result.kind).toBe('unsupported')
+    })
+
+    test('refuses .replace() with no arguments (#1448 Tier B)', () => {
+      // The zero-arg form is degenerate too (both pattern and
+      // replacement coerce to "undefined") — pin it alongside the
+      // one-arg case so neither regresses.
+      const result = parseExpression(`name().replace()`)
+      expect(result.kind).toBe('unsupported')
+    })
+
+    test('.replace with a non-regex unsupported arg surfaces its own reason (#1448 Tier B)', () => {
+      // An object-literal replacement must NOT be mislabelled as the
+      // deferred regex form — the guard only special-cases a
+      // regex-literal pattern.
+      const result = parseExpression(`name().replace("a", {x: 1})`)
+      expect(result.kind).toBe('unsupported')
+      if (result.kind === 'unsupported') {
+        expect(result.reason).not.toContain('regex form is deferred')
+      }
+    })
+
+    test('.replace(/re/, repl) refuses the regex form with the deferred reason (#1448 Tier B)', () => {
+      const result = parseExpression(`name().replace(/a/g, "b")`)
+      expect(result.kind).toBe('unsupported')
+      if (result.kind === 'unsupported') {
+        expect(result.reason).toContain('regex form is deferred')
+      }
+    })
+
+    test('lowers .repeat() and .repeat(n, extra) — full arity (#1448 Tier B)', () => {
+      // `.repeat()` is `repeat(0)` → "" in JS (not a RangeError); a
+      // second+ argument is ignored. Both stay on the lowering path.
+      for (const expr of [`name().repeat()`, `name().repeat(3, 4)`]) {
+        const result = parseExpression(expr)
+        expect(result.kind).toBe('array-method')
+        if (result.kind === 'array-method') {
+          expect(result.method).toBe('repeat')
+        }
+      }
+    })
+
+    test('lowers .padStart() / .padEnd(t, p, extra) — full arity (#1448 Tier B)', () => {
+      // `.padStart()` is `padStart(0)` → the receiver unchanged; a
+      // third+ argument is ignored. Both stay on the lowering path.
+      for (const expr of [`name().padStart()`, `name().padEnd(5, "0", "x")`]) {
+        const result = parseExpression(expr)
+        expect(result.kind).toBe('array-method')
+      }
+    })
+
     test('lowers .filter(({label = `untitled-${suffix}`}) => label) — template-literal default (#1531)', () => {
       const result = parseExpression('items().filter(({label = `untitled-${suffix}`}) => label)')
       expect(result.kind).toBe('higher-order')
@@ -1358,3 +1437,78 @@ describe('expression-parser', () => {
     })
   })
 })
+
+// =============================================================================
+// Full-arity lowering for the array / string methods (#1448)
+// =============================================================================
+//
+// These methods lower at their full JS arity: zero-arg defaults
+// (`.join()` → `,`, `.slice()` → full copy) and JS-ignored trailing
+// arguments (`.trim(1)`, `.at(i, extra)`, `.slice(s, e, extra)`) are all
+// accepted. The only forms still refused are the ones whose EXTRA
+// argument changes the result and isn't lowered yet — the `fromIndex` of
+// `.includes`/`.indexOf`/`.lastIndexOf` and the variadic `.concat(a, b)`
+// — because silently dropping those would make SSR differ from the
+// client (worse than a build error).
+describe('expression-parser — array-method full-arity lowering (#1448)', () => {
+  const supported: Array<[string, string]> = [
+    // base forms
+    ['join(sep)', 'arr.join("-")'],
+    ['includes(x)', 'arr.includes(x)'],
+    ['indexOf(x)', 'arr.indexOf(x)'],
+    ['at(i)', 'arr.at(1)'],
+    ['concat(other)', 'arr.concat(b)'],
+    ['slice(start)', 'arr.slice(1)'],
+    ['slice(start, end)', 'arr.slice(1, 2)'],
+    ['trim()', 's.trim()'],
+    // zero-arg defaults (every one of these escaping both its arm AND
+    // the guard is the footgun the relaxation must NOT reintroduce)
+    ['join() → default ","', 'arr.join()'],
+    ['slice() → full copy', 'arr.slice()'],
+    ['at() → at(0)', 'arr.at()'],
+    ['concat() → shallow copy', 'arr.concat()'],
+    ['reverse() base', 'arr.reverse()'],
+    ['toReversed() base', 'arr.toReversed()'],
+    ['toLowerCase() base', 's.toLowerCase()'],
+    ['toUpperCase() base', 's.toUpperCase()'],
+    ['lastIndexOf(x) base', 'arr.lastIndexOf(x)'],
+    // JS-ignored trailing arguments
+    ['slice(s, e, extra)', 'arr.slice(1, 2, 3)'],
+    ['at(i, extra)', 'arr.at(1, 2)'],
+    ['reverse(extra)', 'arr.reverse(1)'],
+    ['toReversed(extra)', 'arr.toReversed(1)'],
+    ['toLowerCase(extra)', 's.toLowerCase("x")'],
+    ['toUpperCase(extra)', 's.toUpperCase("x")'],
+    ['trim(extra)', 's.trim(1)'],
+  ]
+  for (const [label, expr] of supported) {
+    test(`${label} — lowers to array-method`, () => {
+      expect(parseExpression(expr).kind).toBe('array-method')
+    })
+  }
+
+  // Still refused (the extra argument is meaningful and not yet
+  // lowered), plus the degenerate zero-arg search forms (`includes()`
+  // searches for `undefined` — refused rather than guessed).
+  const refused: Array<[string, string]> = [
+    ['includes(x, fromIndex)', 'arr.includes(x, 1)'],
+    ['indexOf(x, fromIndex)', 'arr.indexOf(x, 1)'],
+    ['lastIndexOf(x, fromIndex)', 'arr.lastIndexOf(x, 1)'],
+    ['concat(a, b) variadic', 'arr.concat(a, b)'],
+    ['includes() zero-arg', 'arr.includes()'],
+    ['indexOf() zero-arg', 'arr.indexOf()'],
+  ]
+  for (const [label, expr] of refused) {
+    test(`${label} — refuses (meaningful extra arg, not yet lowered)`, () => {
+      const result = parseExpression(expr)
+      expect(result.kind).toBe('unsupported')
+      if (result.kind === 'unsupported') {
+        // Must NOT push `@client` (wrong remedy; doesn't work in
+        // attribute / condition position), and must explain it's a
+        // not-yet-lowered argument.
+        expect(result.reason).not.toContain('@client')
+        expect(result.reason).toContain('not yet lowered')
+      }
+    })
+  }
+})

package/src/__tests__/ir-to-client-js/reactivity.test.ts

@@ -23,6 +23,7 @@ function makeContext(overrides: Partial<ClientJsContext> = {}): ClientJsContext
     loopElements: [],
     refElements: [],
     childInits: [],
+    deferredChildSlots: new Set(),
     reactiveProps: [],
     reactiveChildProps: [],
     reactiveAttrs: [],

package/src/__tests__/staged-ir/06-multi-stage-soak.test.ts

@@ -80,9 +80,24 @@ describe('Multi-stage soak (DeskCanvas-shape)', () => {
     expect(clientJs).toMatch(/import\s+\{[^}]*useYjs[^}]*\}\s+from\s+['"]\.\/useYjs['"]/)
   })
 
-  test('Module → Template: nodeTypes import IS visible to template', () => {
-    const { templateBody } = compile(DESK_CANVAS_SHAPE, 'DeskCanvas.tsx')
-    expect(templateBody).toMatch(/nodeTypes/)
+  test('Module → Init: nodeTypes is forwarded to the deferred child via init', () => {
+    // The `<Flow>` render carries init-scope-only props (`data-yjs={yjs.id}`
+    // where `yjs` is an init-local; `nodes={items()}`). The module-scope
+    // template lambda can't supply those, so the child render is DEFERRED
+    // to a `data-bf-ph` placeholder and `upsertChild` (→ createComponent)
+    // creates `Flow` with the COMPLETE getter props. The inlinable
+    // `nodeTypes` is therefore forwarded through the init `upsertChild`
+    // getter — never dropped — rather than baked into the template lambda.
+    // (Pre-fix this child was rendered eagerly via `renderChild('Flow', {
+    // nodeTypes })` with the init-scope props silently dropped — the
+    // dropped-prop bug.)
+    const { templateBody, initBody } = compile(DESK_CANVAS_SHAPE, 'DeskCanvas.tsx')
+    // Template defers the child render with a placeholder, not renderChild.
+    expect(templateBody).toMatch(/data-bf-ph="s0"/)
+    expect(templateBody).not.toMatch(/renderChild/)
+    // Init forwards nodeTypes (and every other prop) with complete values.
+    expect(initBody).toMatch(/upsertChild\(__scope,\s*'Flow',\s*'s0'/)
+    expect(initBody).toMatch(/get nodeTypes\(\)\s*\{\s*return nodeTypes\s*\}/)
   })
 
   // TODO(#1138 P3 5/N): `useYjs(...)` (init-local initializer) leaks into

package/src/adapters/parsed-expr-emitter.ts

@@ -66,6 +66,13 @@ export type ArrayMethod =
   | 'toLowerCase'
   | 'toUpperCase'
   | 'trim'
+  | 'split'
+  | 'startsWith'
+  | 'endsWith'
+  | 'replace'
+  | 'repeat'
+  | 'padStart'
+  | 'padEnd'
 
 /**
  * Method names handled by the dedicated `sortMethod()` dispatcher

package/src/expression-parser.ts

@@ -46,6 +46,13 @@ export type ParsedExpr =
         | 'toLowerCase'
         | 'toUpperCase'
         | 'trim'
+        | 'split'
+        | 'startsWith'
+        | 'endsWith'
+        | 'replace'
+        | 'repeat'
+        | 'padStart'
+        | 'padEnd'
       object: ParsedExpr
       args: ParsedExpr[]
     }
@@ -225,12 +232,46 @@ const UNSUPPORTED_METHODS = new Set([
   // unsupported array methods above get), pointing users at the
   // `/* @client */` escape hatch. Each name drops off as its lowering
   // lands. See #1448 "Unsupported string methods" Tier B / Tier C.
-  'split', 'startsWith', 'endsWith', 'replace', 'replaceAll',
-  'repeat', 'padStart', 'padEnd',
+  // `split` is no longer here — `String.prototype.split(sep)` lowers
+  // via the `array-method` IR + `bf_split` (Go) / `bf->split` (Mojo),
+  // returning an array that composes with `.join()` / `.map()` / etc.
+  // See #1448 Tier B.
+  // `startsWith` / `endsWith` are no longer here — both lower via the
+  // `array-method` IR + `bf_starts_with` / `bf_ends_with` (Go) and
+  // `bf->starts_with` / `bf->ends_with` (Mojo). See #1448 Tier B.
+  // `replace` is no longer here — the string-pattern form lowers via
+  // the `array-method` IR + `bf_replace` (Go) / `bf->replace` (Mojo);
+  // the regex-pattern form is refused at the parse arm below (it would
+  // need the per-adapter regex-flavour decision). `replaceAll` stays
+  // refused. See #1448 Tier B.
+  // `repeat` is no longer here — `String.prototype.repeat(n)` lowers via
+  // the `array-method` IR + `bf_repeat` (Go) / `bf->repeat` (Mojo).
+  // See #1448 Tier B.
+  // `padStart` / `padEnd` are no longer here — both lower via the
+  // `array-method` IR + `bf_pad_start` / `bf_pad_end` (Go) and
+  // `bf->pad_start` / `bf->pad_end` (Mojo). See #1448 Tier B.
+  'replaceAll',
   'charAt', 'charCodeAt', 'codePointAt', 'normalize',
   'substring', 'substr', 'match', 'matchAll', 'search',
 ])
 
+// Methods that lower at their single-argument form but whose EXTRA
+// argument is meaningful and NOT yet lowered: the `fromIndex` of
+// `.includes` / `.indexOf` / `.lastIndexOf` (the 2-arg form) and the
+// additional arrays of a variadic `.concat(a, b, …)`. The relaxed
+// per-method arms in `convertNode` accept every method's zero-arg
+// defaults (`.join()` / `.slice()` / `.concat()` / `.at()`) and
+// JS-ignored trailing arguments; this guard catches only the remaining
+// meaningful-extra forms, refusing them with BF101 because silently
+// dropping the argument would make the SSR output differ from the
+// client. See #1448.
+const LOWERED_ARRAY_METHODS = new Set([
+  'includes',
+  'indexOf',
+  'lastIndexOf',
+  'concat',
+])
+
 // =============================================================================
 // Expression Parser
 // =============================================================================
@@ -344,7 +385,10 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
     // etc. later means widening the IR discriminator, not adding more
     // branches to every adapter's call dispatch.
     if (callee.kind === 'member' && !callee.computed) {
-      if (callee.property === 'join' && args.length === 1) {
+      // `.join()` / `.join(sep)` — JS defaults the separator to `,` when
+      // omitted and ignores any extra arguments. Accept every arity; the
+      // adapters supply the default separator and read only `args[0]`.
+      if (callee.property === 'join') {
         return { kind: 'array-method', method: 'join', object: callee.object, args }
       }
       // `.includes(x)` — shared between `Array.prototype.includes` and
@@ -369,20 +413,28 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
       // element). Go has `bf_at` registered already (see runtime
       // FuncMap); Mojo's `bf->at` wraps the same arithmetic.
       // See #1448 Tier A.
-      if (callee.property === 'at' && args.length === 1) {
+      // `.at(i)` — JS ignores any argument past the first, and `.at()`
+      // with no argument is `.at(0)` (the first element). Accept every
+      // arity; the adapters read `args[0]` (defaulting the index to 0).
+      if (callee.property === 'at') {
         return { kind: 'array-method', method: 'at', object: callee.object, args }
       }
-      // `.concat(other)` — merges two arrays in order. Go uses
-      // `bf_concat` (reflect-based append into `[]any`); Mojo uses
-      // `bf->concat` (Perl list builder). Variadic shapes (`.concat(a, b)`)
-      // are out of scope for this PR — gated to single-arg here.
-      if (callee.property === 'concat' && args.length === 1) {
+      // `.concat()` / `.concat(other)` — `.concat()` returns a shallow
+      // copy (indistinguishable from the receiver in an SSR snapshot),
+      // and `.concat(other)` merges the two arrays. Go uses `bf_concat`
+      // (reflect-based append into `[]any`); Mojo uses `bf->concat`
+      // (Perl list builder). The VARIADIC form (`.concat(a, b, …)`) is
+      // not lowered yet — it's refused by the guard below rather than
+      // silently dropping the extra arrays.
+      if (callee.property === 'concat' && args.length <= 1) {
         return { kind: 'array-method', method: 'concat', object: callee.object, args }
       }
-      // `.slice(start)` / `.slice(start, end)` — both forms route
-      // through `bf_slice` (Go) / `bf->slice` (Mojo); the helpers
-      // treat a missing / undef `end` as "to length".
-      if (callee.property === 'slice' && (args.length === 1 || args.length === 2)) {
+      // `.slice()` / `.slice(start)` / `.slice(start, end)` — route
+      // through `bf_slice` (Go) / `bf->slice` (Mojo). A missing `start`
+      // defaults to 0 (full copy), a missing / undef `end` means "to
+      // length", and JS ignores any third+ argument. Accept every arity;
+      // the adapters read only `args[0]` / `args[1]`.
+      if (callee.property === 'slice') {
         return { kind: 'array-method', method: 'slice', object: callee.object, args }
       }
       // `.reverse()` and `.toReversed()` — both zero-arg shapes
@@ -390,7 +442,8 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
       // of state, so JS's mutate-and-return-receiver (`reverse`)
       // vs return-new-array (`toReversed`) distinction has no
       // template-level meaning; both produce a new reversed array.
-      if ((callee.property === 'reverse' || callee.property === 'toReversed') && args.length === 0) {
+      // JS takes no argument and ignores any that are passed.
+      if (callee.property === 'reverse' || callee.property === 'toReversed') {
         return { kind: 'array-method', method: callee.property, object: callee.object, args }
       }
       // `.toLowerCase()` — string-only (the IR carries a value-builtin
@@ -398,20 +451,150 @@ function convertNode(node: ts.Node, raw: string): ParsedExpr {
       // label is a misnomer for string methods but the mechanical
       // pipeline matches). Go uses the existing `bf_lower` helper;
       // Mojo uses Perl's native `lc`. See #1448 Tier A.
-      if (callee.property === 'toLowerCase' && args.length === 0) {
+      if (callee.property === 'toLowerCase') {
         return { kind: 'array-method', method: 'toLowerCase', object: callee.object, args }
       }
       // `.toUpperCase()` — Go uses the existing `bf_upper` helper;
       // Mojo uses Perl's native `uc`.
-      if (callee.property === 'toUpperCase' && args.length === 0) {
+      if (callee.property === 'toUpperCase') {
         return { kind: 'array-method', method: 'toUpperCase', object: callee.object, args }
       }
       // `.trim()` — Go uses the existing `bf_trim` helper; Mojo uses
       // a new `bf->trim` method that mirrors JS's "strip leading +
       // trailing whitespace" semantic via a Perl regex.
-      if (callee.property === 'trim' && args.length === 0) {
+      if (callee.property === 'trim') {
         return { kind: 'array-method', method: 'trim', object: callee.object, args }
       }
+      // `.split()` / `.split(sep)` / `.split(sep, limit)` — string →
+      // array, full JS arity. `.split()` (no separator) returns the
+      // whole string as a single element; `.split(sep)` splits on the
+      // (literal) separator; the optional `limit` caps the number of
+      // pieces. JS ignores a third+ argument. Go uses `bf_split`
+      // (`strings.Split`, optional limit, normalised to `[]any`) and
+      // `bf_arr` for the no-separator whole-string case; Mojo uses
+      // `bf->split`. The regex-separator form stays refused (the parser
+      // never reaches here for it — a regex literal arg is `unsupported`
+      // and propagates). See #1448 Tier B.
+      if (callee.property === 'split') {
+        return { kind: 'array-method', method: 'split', object: callee.object, args }
+      }
+      // Arity guard for the forms whose EXTRA argument changes the
+      // result and is not yet lowered: the `fromIndex` of `.includes` /
+      // `.indexOf` / `.lastIndexOf` (the 2-arg form), and the additional
+      // arrays of a variadic `.concat(a, b, …)`. Silently dropping those
+      // would make the SSR output *differ* from the client (worse than a
+      // build error), so they refuse with BF101 until lowered. (The
+      // single-argument forms, zero-arg defaults, and JS-ignored
+      // trailing arguments of every method are accepted by the relaxed
+      // arms above.) See #1448.
+      if (LOWERED_ARRAY_METHODS.has(callee.property)) {
+        const argName = callee.property === 'concat' ? 'other' : 'x'
+        const detail =
+          callee.property === 'concat'
+            ? 'the variadic `.concat(a, b, …)` form'
+            : `\`.${callee.property}(…)\` with ${args.length} argument(s)`
+        return {
+          kind: 'unsupported',
+          raw,
+          reason: `${detail} is not yet lowered to the Go/Mojo template adapters. Use the single-argument \`.${callee.property}(${argName})\` form, or pre-compute the value before the template.`,
+        }
+      }
+      // `.startsWith(search, position?)` / `.endsWith(search, endPosition?)`
+      // — string → boolean, full JS arity. Go uses `bf_starts_with` /
+      // `bf_ends_with` (wrapping `strings.HasPrefix` / `strings.HasSuffix`,
+      // with an optional position that re-anchors the comparison); Mojo
+      // uses `bf->starts_with` / `bf->ends_with` (substr comparison). JS
+      // ignores a third+ argument. The zero-arg form (`.startsWith()`) is
+      // refused: JS coerces the missing search to the literal string
+      // "undefined", a degenerate result not worth lowering (mirrors the
+      // `.includes()` zero-arg refusal). See #1448 Tier B.
+      if (callee.property === 'startsWith' || callee.property === 'endsWith') {
+        if (args.length === 0) {
+          return {
+            kind: 'unsupported',
+            raw,
+            reason: `\`.${callee.property}()\` with no search string is not lowered — JS coerces the missing argument to the string "undefined", a degenerate result. Pass an explicit search string, or pre-compute the value before the template.`,
+          }
+        }
+        return { kind: 'array-method', method: callee.property, object: callee.object, args }
+      }
+      // `.replace(pattern, replacement)` — string-pattern form,
+      // replacing the FIRST occurrence (JS semantics for a string
+      // pattern). Go uses `bf_replace` (`strings.Replace` with n=1);
+      // Mojo uses `bf->replace` (index/substr splice, no regex). A
+      // regex-literal pattern parses as `unsupported` (convertNode has
+      // no regex arm), so it's refused explicitly here rather than
+      // emitting a broken `.Replace` — the Perl `s///` vs Go
+      // `regexp.ReplaceAllString` flavour gap is the open design
+      // question in #1448. `replaceAll` stays refused entirely.
+      //
+      // Full JS arity: a third+ argument is ignored (the adapter reads
+      // only the pattern + replacement). The one- and zero-argument
+      // forms are refused: JS coerces the missing replacement (and
+      // pattern) to the literal string "undefined", a degenerate result
+      // (mirrors the `.includes()` / `.startsWith()` zero-arg refusal).
+      if (callee.property === 'replace') {
+        if (args.length < 2) {
+          return {
+            kind: 'unsupported',
+            raw,
+            reason: `\`.replace(${args.length === 0 ? '' : 'pattern'})\` needs both a pattern and a replacement — JS coerces the missing argument to the string "undefined", a degenerate result. Pass both arguments, or pre-compute the value before the template.`,
+          }
+        }
+        // A regex-literal pattern is the deferred form (the Perl `s///`
+        // vs Go `regexp.ReplaceAllString` flavour gap, #1448) — detect it
+        // on the TS node so the message is accurate. Any OTHER unsupported
+        // pattern/replacement (an object literal, an unsupported call, …)
+        // surfaces ITS OWN reason rather than being mislabelled as the
+        // regex form.
+        const patternNode = node.arguments[0]
+        if (patternNode && ts.isRegularExpressionLiteral(patternNode)) {
+          return {
+            kind: 'unsupported',
+            raw,
+            reason:
+              'String.prototype.replace supports only a string pattern + string replacement (the regex form is deferred); use a string pattern or wrap the expression in /* @client */',
+          }
+        }
+        const badArg =
+          args[0].kind === 'unsupported'
+            ? args[0]
+            : args[1].kind === 'unsupported'
+              ? args[1]
+              : undefined
+        if (badArg && badArg.kind === 'unsupported') {
+          return { kind: 'unsupported', raw, reason: badArg.reason }
+        }
+        return { kind: 'array-method', method: 'replace', object: callee.object, args }
+      }
+      // `.repeat(n)` — string → string (the receiver concatenated `n`
+      // times). Go uses `bf_repeat` (`strings.Repeat`, clamping a
+      // negative count to "" instead of panicking); Mojo uses
+      // `bf->repeat` (Perl's `x` operator). JS throws RangeError for a
+      // negative count, but SSR templates degrade to the empty string
+      // rather than crashing the render. See #1448 Tier B.
+      // Full JS arity: `.repeat()` (no count) is `repeat(0)` → "" (JS
+      // coerces the missing count to 0, not a RangeError), and a
+      // second+ argument is ignored. The adapter supplies the `0` for
+      // the no-argument form. See #1448 Tier B.
+      if (callee.property === 'repeat') {
+        return { kind: 'array-method', method: 'repeat', object: callee.object, args }
+      }
+      // `.padStart(target, pad?)` / `.padEnd(target, pad?)` — string →
+      // string, padded to `target` length with `pad` (default a single
+      // space) repeated + truncated to fill. Go uses `bf_pad_start` /
+      // `bf_pad_end`; Mojo uses `bf->pad_start` / `bf->pad_end`. Both
+      // count length in code points (Go runes / Perl chars) so they
+      // stay byte-equal — this differs from JS's UTF-16-unit length
+      // only for astral-plane receivers, which are vanishingly rare in
+      // numeric / space padding. See #1448 Tier B.
+      // Full JS arity: `.padStart()` (no target) is `padStart(0)` → the
+      // receiver unchanged (JS coerces the missing target to 0), and a
+      // third+ argument is ignored. The adapter supplies the `0` for the
+      // no-argument form and reads only target + padString.
+      if (callee.property === 'padStart' || callee.property === 'padEnd') {
+        return { kind: 'array-method', method: callee.property, object: callee.object, args }
+      }
       // `.sort(cmp)` / `.toSorted(cmp)` (#1448 Tier B). The comparator
       // is extracted into a structured `SortComparator` at parse time;
       // unrecognised shapes fall through to `unsupported` so adapters

package/src/ir-to-client-js/emit-registration.ts

@@ -168,7 +168,7 @@ export function emitRegistrationAndHydration(
     // transformation runs at this layer (#1277).
     const csrInlinableConstants = csrInlinableConstantsFromCtx(ctx)
     const templateHtml = generateCsrTemplate(
-      _ir.root, csrInlinableConstants, ctx, undefined, restSpreadNames, ctx.propsObjectName, unsafeLocalNames
+      _ir.root, csrInlinableConstants, ctx, undefined, restSpreadNames, ctx.propsObjectName, unsafeLocalNames, ctx.deferredChildSlots
     )
     if (templateHtml) {
       defParts.push(`template: (${PROPS_PARAM}) => \`${templateHtml}\``)

package/src/ir-to-client-js/generate-init.ts

@@ -14,7 +14,8 @@ import { PROPS_PARAM } from './utils'
 import { buildReferencesGraph } from './build-references'
 import { computePropUsage } from './compute-prop-usage'
 import { IMPORT_PLACEHOLDER, MODULE_CONSTANTS_PLACEHOLDER } from './imports'
-import { emitRegistrationAndHydration } from './emit-registration'
+import { emitRegistrationAndHydration, csrInlinableConstantsFromCtx } from './emit-registration'
+import { computeDeferredChildSlots } from './html-template'
 import { emitChildComponentImports } from './child-components'
 import { classifyLocalDeclarations } from './init-declarations'
 import { emitModuleLevelDeclarations, resolveFinalImports } from './emit-module-level'
@@ -55,6 +56,20 @@ export function generateInitFunction(
   // duplicate warnings (#1247).
   const inlinability = buildInlinableConstants(ctx, graph, ir.root)
 
+  // Decide which direct child components must defer their render to init
+  // because a forwarded prop resolves to an init-scope-only / non-inlinable
+  // local (dropped-prop fix). The child-init phase reads this set to emit
+  // `upsertChild` instead of `initChild`; `emitRegistrationAndHydration`
+  // reads it to emit a `data-bf-ph` placeholder instead of
+  // `renderChild(...)`. Computed here, once `unsafeLocalNames` is known.
+  ctx.deferredChildSlots = computeDeferredChildSlots(
+    ir.root,
+    ctx,
+    csrInlinableConstantsFromCtx(ctx),
+    inlinability.unsafeLocalNames,
+    ctx.propsObjectName,
+  )
+
   // --- Emission: declarative phase pipeline. Each entry in `PHASES`
   //     declares its inputs (dependsOn) and emission action (run); the
   //     stable topological execution preserves the legacy by-position