@barefootjs/mojolicious 0.5.2 → 0.6.0

package/dist/adapter/index.js

@@ -770,7 +770,7 @@ function renderArrayMethod(method, object, args, emit) {
   switch (method) {
     case "join": {
       const obj = emit(object);
-      const sep = emit(args[0]);
+      const sep = args.length >= 1 ? emit(args[0]) : `','`;
       return `join(${sep}, @{${obj}})`;
     }
     case "includes": {
@@ -787,18 +787,21 @@ function renderArrayMethod(method, object, args, emit) {
     }
     case "at": {
       const obj = emit(object);
-      const idx = emit(args[0]);
+      const idx = args.length >= 1 ? emit(args[0]) : "0";
       return `bf->at(${obj}, ${idx})`;
     }
     case "concat": {
+      if (args.length === 0) {
+        return emit(object);
+      }
       const a = emit(object);
       const b = emit(args[0]);
       return `bf->concat(${a}, ${b})`;
     }
     case "slice": {
       const recv = emit(object);
-      const start = emit(args[0]);
-      const end = args.length === 2 ? emit(args[1]) : "undef";
+      const start = args.length >= 1 ? emit(args[0]) : "0";
+      const end = args.length >= 2 ? emit(args[1]) : "undef";
       return `bf->slice(${recv}, ${start}, ${end})`;
     }
     case "reverse":
@@ -818,6 +821,53 @@ function renderArrayMethod(method, object, args, emit) {
       const recv = emit(object);
       return `bf->trim(${recv})`;
     }
+    case "split": {
+      const recv = emit(object);
+      if (args.length === 0) {
+        return `bf->split(${recv})`;
+      }
+      const sep = emit(args[0]);
+      if (args.length === 1) {
+        return `bf->split(${recv}, ${sep})`;
+      }
+      const limit = emit(args[1]);
+      return `bf->split(${recv}, ${sep}, ${limit})`;
+    }
+    case "startsWith":
+    case "endsWith": {
+      const fn = method === "startsWith" ? "starts_with" : "ends_with";
+      const recv = emit(object);
+      const arg = emit(args[0]);
+      if (args.length >= 2) {
+        return `bf->${fn}(${recv}, ${arg}, ${emit(args[1])})`;
+      }
+      return `bf->${fn}(${recv}, ${arg})`;
+    }
+    case "replace": {
+      const recv = emit(object);
+      const oldS = emit(args[0]);
+      const newS = emit(args[1]);
+      return `bf->replace(${recv}, ${oldS}, ${newS})`;
+    }
+    case "repeat": {
+      const recv = emit(object);
+      const count = args.length === 0 ? "0" : emit(args[0]);
+      return `bf->repeat(${recv}, ${count})`;
+    }
+    case "padStart":
+    case "padEnd": {
+      const fn = method === "padStart" ? "pad_start" : "pad_end";
+      const recv = emit(object);
+      if (args.length === 0) {
+        return `bf->${fn}(${recv}, 0)`;
+      }
+      const target = emit(args[0]);
+      if (args.length === 1) {
+        return `bf->${fn}(${recv}, ${target})`;
+      }
+      const pad = emit(args[1]);
+      return `bf->${fn}(${recv}, ${target}, ${pad})`;
+    }
     default: {
       const _exhaustive = method;
       throw new Error(`renderArrayMethod: unhandled ArrayMethod '${_exhaustive}'`);

package/dist/adapter/mojo-adapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mojo-adapter.d.ts","sourceRoot":"","sources":["../../src/adapter/mojo-adapter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"mojo-adapter.d.ts","sourceRoot":"","sources":["../../src/adapter/mojo-adapter.ts"],"names":[],"mappings":"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"}

package/dist/build.js

@@ -770,7 +770,7 @@ function renderArrayMethod(method, object, args, emit) {
   switch (method) {
     case "join": {
       const obj = emit(object);
-      const sep = emit(args[0]);
+      const sep = args.length >= 1 ? emit(args[0]) : `','`;
       return `join(${sep}, @{${obj}})`;
     }
     case "includes": {
@@ -787,18 +787,21 @@ function renderArrayMethod(method, object, args, emit) {
     }
     case "at": {
       const obj = emit(object);
-      const idx = emit(args[0]);
+      const idx = args.length >= 1 ? emit(args[0]) : "0";
       return `bf->at(${obj}, ${idx})`;
     }
     case "concat": {
+      if (args.length === 0) {
+        return emit(object);
+      }
       const a = emit(object);
       const b = emit(args[0]);
       return `bf->concat(${a}, ${b})`;
     }
     case "slice": {
       const recv = emit(object);
-      const start = emit(args[0]);
-      const end = args.length === 2 ? emit(args[1]) : "undef";
+      const start = args.length >= 1 ? emit(args[0]) : "0";
+      const end = args.length >= 2 ? emit(args[1]) : "undef";
       return `bf->slice(${recv}, ${start}, ${end})`;
     }
     case "reverse":
@@ -818,6 +821,53 @@ function renderArrayMethod(method, object, args, emit) {
       const recv = emit(object);
       return `bf->trim(${recv})`;
     }
+    case "split": {
+      const recv = emit(object);
+      if (args.length === 0) {
+        return `bf->split(${recv})`;
+      }
+      const sep = emit(args[0]);
+      if (args.length === 1) {
+        return `bf->split(${recv}, ${sep})`;
+      }
+      const limit = emit(args[1]);
+      return `bf->split(${recv}, ${sep}, ${limit})`;
+    }
+    case "startsWith":
+    case "endsWith": {
+      const fn = method === "startsWith" ? "starts_with" : "ends_with";
+      const recv = emit(object);
+      const arg = emit(args[0]);
+      if (args.length >= 2) {
+        return `bf->${fn}(${recv}, ${arg}, ${emit(args[1])})`;
+      }
+      return `bf->${fn}(${recv}, ${arg})`;
+    }
+    case "replace": {
+      const recv = emit(object);
+      const oldS = emit(args[0]);
+      const newS = emit(args[1]);
+      return `bf->replace(${recv}, ${oldS}, ${newS})`;
+    }
+    case "repeat": {
+      const recv = emit(object);
+      const count = args.length === 0 ? "0" : emit(args[0]);
+      return `bf->repeat(${recv}, ${count})`;
+    }
+    case "padStart":
+    case "padEnd": {
+      const fn = method === "padStart" ? "pad_start" : "pad_end";
+      const recv = emit(object);
+      if (args.length === 0) {
+        return `bf->${fn}(${recv}, 0)`;
+      }
+      const target = emit(args[0]);
+      if (args.length === 1) {
+        return `bf->${fn}(${recv}, ${target})`;
+      }
+      const pad = emit(args[1]);
+      return `bf->${fn}(${recv}, ${target}, ${pad})`;
+    }
     default: {
       const _exhaustive = method;
       throw new Error(`renderArrayMethod: unhandled ArrayMethod '${_exhaustive}'`);

package/dist/index.js

@@ -770,7 +770,7 @@ function renderArrayMethod(method, object, args, emit) {
   switch (method) {
     case "join": {
       const obj = emit(object);
-      const sep = emit(args[0]);
+      const sep = args.length >= 1 ? emit(args[0]) : `','`;
       return `join(${sep}, @{${obj}})`;
     }
     case "includes": {
@@ -787,18 +787,21 @@ function renderArrayMethod(method, object, args, emit) {
     }
     case "at": {
       const obj = emit(object);
-      const idx = emit(args[0]);
+      const idx = args.length >= 1 ? emit(args[0]) : "0";
       return `bf->at(${obj}, ${idx})`;
     }
     case "concat": {
+      if (args.length === 0) {
+        return emit(object);
+      }
       const a = emit(object);
       const b = emit(args[0]);
       return `bf->concat(${a}, ${b})`;
     }
     case "slice": {
       const recv = emit(object);
-      const start = emit(args[0]);
-      const end = args.length === 2 ? emit(args[1]) : "undef";
+      const start = args.length >= 1 ? emit(args[0]) : "0";
+      const end = args.length >= 2 ? emit(args[1]) : "undef";
       return `bf->slice(${recv}, ${start}, ${end})`;
     }
     case "reverse":
@@ -818,6 +821,53 @@ function renderArrayMethod(method, object, args, emit) {
       const recv = emit(object);
       return `bf->trim(${recv})`;
     }
+    case "split": {
+      const recv = emit(object);
+      if (args.length === 0) {
+        return `bf->split(${recv})`;
+      }
+      const sep = emit(args[0]);
+      if (args.length === 1) {
+        return `bf->split(${recv}, ${sep})`;
+      }
+      const limit = emit(args[1]);
+      return `bf->split(${recv}, ${sep}, ${limit})`;
+    }
+    case "startsWith":
+    case "endsWith": {
+      const fn = method === "startsWith" ? "starts_with" : "ends_with";
+      const recv = emit(object);
+      const arg = emit(args[0]);
+      if (args.length >= 2) {
+        return `bf->${fn}(${recv}, ${arg}, ${emit(args[1])})`;
+      }
+      return `bf->${fn}(${recv}, ${arg})`;
+    }
+    case "replace": {
+      const recv = emit(object);
+      const oldS = emit(args[0]);
+      const newS = emit(args[1]);
+      return `bf->replace(${recv}, ${oldS}, ${newS})`;
+    }
+    case "repeat": {
+      const recv = emit(object);
+      const count = args.length === 0 ? "0" : emit(args[0]);
+      return `bf->repeat(${recv}, ${count})`;
+    }
+    case "padStart":
+    case "padEnd": {
+      const fn = method === "padStart" ? "pad_start" : "pad_end";
+      const recv = emit(object);
+      if (args.length === 0) {
+        return `bf->${fn}(${recv}, 0)`;
+      }
+      const target = emit(args[0]);
+      if (args.length === 1) {
+        return `bf->${fn}(${recv}, ${target})`;
+      }
+      const pad = emit(args[1]);
+      return `bf->${fn}(${recv}, ${target}, ${pad})`;
+    }
     default: {
       const _exhaustive = method;
       throw new Error(`renderArrayMethod: unhandled ArrayMethod '${_exhaustive}'`);

package/lib/BarefootJS.pm

@@ -526,6 +526,172 @@ sub trim ($self, $recv) {
     return $s;
 }
 
+# `String.prototype.split(sep)` (#1448 Tier B) — string → ARRAY ref.
+#
+# Two JS-parity wrinkles drive the helper (a bare `split` emit would
+# diverge from both JS and Go):
+#
+#   * Perl's `split` treats its first argument as a *regex*, so a
+#     separator like '.' or '|' would match far too much. We
+#     `quotemeta` it to force literal-string matching, mirroring JS's
+#     string-separator semantics (the regex-separator form stays
+#     refused upstream — see the parser arm).
+#   * Perl's `split` drops trailing empty fields by default; JS keeps
+#     them (`"a,".split(",")` is `["a", ""]`). Passing the `-1` limit
+#     preserves them, matching JS and Go's `strings.Split`.
+#
+# An empty separator splits into individual characters (JS + Go agree).
+# Undef receiver renders as the single-element `['']` — the same
+# "missing prop → empty string" convention `bf->trim` uses.
+
+sub split ($self, $recv, $sep = undef, $limit = undef) {
+    my $s = defined $recv && !ref($recv) ? "$recv" : '';
+
+    my @parts;
+    if (!defined $sep) {
+        # No separator → the whole string in a single-element array
+        # (matches JS `"x".split()` / `.split(undefined)`).
+        @parts = ($s);
+    }
+    elsif ("$sep" eq '') {
+        # Empty separator → individual characters. No `-1` limit here:
+        # on an empty pattern Perl's `split` with `-1` appends a spurious
+        # trailing empty field ("abc" → 'a','b','c',''), which JS/Go don't.
+        @parts = split //, $s;
+    }
+    elsif ($s eq '') {
+        # Empty input with a non-empty separator: JS `"".split(",")` is
+        # `[""]` and Go's `strings.Split("", ",")` is `[""]`, but Perl's
+        # `split /,/, ''` returns the empty list — special-case for parity.
+        @parts = ('');
+    }
+    else {
+        # `quotemeta` forces literal-string matching (JS string-separator
+        # semantics); the `-1` keeps trailing empty fields (JS keeps them,
+        # Perl's bare `split` drops them).
+        my $q = quotemeta("$sep");
+        @parts = split /$q/, $s, -1;
+    }
+
+    # Optional `limit` caps the number of pieces (JS `split(sep, limit)`).
+    # 0 → empty; a negative limit keeps all (JS ToUint32 wrap makes it
+    # effectively unbounded) — both match Go's `bf_split`.
+    if (defined $limit) {
+        my $n = int($limit);
+        if ($n == 0) { @parts = () }
+        elsif ($n > 0 && $n < scalar @parts) { @parts = @parts[0 .. $n - 1] }
+    }
+
+    return [@parts];
+}
+
+# `String.prototype.startsWith(prefix, position?)` (#1448 Tier B) —
+# string → boolean (1 / 0). `substr`-anchored literal comparison mirrors
+# Go's `strings.HasPrefix`. An empty prefix is always true (JS parity);
+# undef / non-string receivers coerce to the empty string first. The
+# optional `position` re-anchors the test (clamped to `[0, length]`),
+# matching JS `"abc".startsWith("b", 1)`.
+
+sub starts_with ($self, $recv, $prefix, $position = undef) {
+    my $s = defined $recv && !ref($recv) ? "$recv" : '';
+    my $p = defined $prefix ? "$prefix" : '';
+    if (defined $position) {
+        my $n = int($position);
+        $n = 0 if $n < 0;
+        $n = length($s) if $n > length($s);
+        $s = substr($s, $n);
+    }
+    return substr($s, 0, length $p) eq $p ? 1 : 0;
+}
+
+# `String.prototype.endsWith(suffix, endPosition?)` (#1448 Tier B) —
+# string → boolean (1 / 0). Mirrors Go's `strings.HasSuffix`. An empty
+# suffix is always true (JS parity); a suffix longer than the string is
+# false. `substr($s, -length $x)` would mis-read the whole string when
+# `length $x == 0`, so that case short-circuits. The optional
+# `endPosition` treats the string as if it were only that many chars
+# long (clamped to `[0, length]`), matching JS `"abc".endsWith("b", 2)`.
+
+sub ends_with ($self, $recv, $suffix, $end_position = undef) {
+    my $s = defined $recv && !ref($recv) ? "$recv" : '';
+    my $x = defined $suffix ? "$suffix" : '';
+    if (defined $end_position) {
+        my $e = int($end_position);
+        $e = 0 if $e < 0;
+        $e = length($s) if $e > length($s);
+        $s = substr($s, 0, $e);
+    }
+    return 1 if $x eq '';
+    return 0 if length($s) < length($x);
+    return substr($s, -length $x) eq $x ? 1 : 0;
+}
+
+# `String.prototype.replace(pattern, replacement)` — string-pattern
+# form only (#1448 Tier B), replacing the FIRST occurrence (JS string-
+# pattern semantics). Spliced via index/substr rather than `s///` so
+# BOTH the pattern and the replacement are literal: no Perl regex
+# metacharacters in the pattern and no `$1` / `$&` interpolation in the
+# replacement. Go's `bf_replace` (strings.Replace, n=1) treats the
+# replacement literally too, so the two adapters stay byte-equal — this
+# diverges from JS only for replacement strings containing `$`-patterns
+# (rare in template position). An empty pattern inserts the replacement
+# at the front (`"abc".replace("", "X")` → "Xabc"), matching JS + Go.
+
+sub replace ($self, $recv, $pattern, $replacement) {
+    my $s = defined $recv && !ref($recv) ? "$recv" : '';
+    my $o = defined $pattern ? "$pattern" : '';
+    my $n = defined $replacement ? "$replacement" : '';
+    return $n . $s if $o eq '';
+    my $i = index($s, $o);
+    return $s if $i < 0;
+    return substr($s, 0, $i) . $n . substr($s, $i + length($o));
+}
+
+# `String.prototype.repeat(n)` — the receiver concatenated n times
+# (#1448 Tier B), via Perl's `x` operator. JS throws RangeError for a
+# negative count, but SSR templates degrade to the empty string rather
+# than dying mid-render, so a count <= 0 returns "" (Go's `bf_repeat`
+# applies the same clamp). The count is truncated toward zero
+# (`int`), matching JS's ToIntegerOrInfinity on `"a".repeat(3.7)`.
+
+sub repeat ($self, $recv, $count) {
+    my $s = defined $recv && !ref($recv) ? "$recv" : '';
+    my $n = defined $count ? int($count) : 0;
+    return $n <= 0 ? '' : $s x $n;
+}
+
+# `String.prototype.padStart` / `padEnd` (#1448 Tier B) — pad the
+# receiver to `$target` characters with `$pad` (default a single space)
+# repeated and truncated to fill, prepended or appended. Length is
+# measured in characters (Perl `length`), matching Go's rune-based
+# `bf_pad_*` — diverges from JS's UTF-16-unit length only for
+# astral-plane input. An empty pad, or a receiver already >= `$target`,
+# returns the receiver unchanged (JS parity). The `$target` is
+# truncated toward zero (JS ToLength on the first arg).
+
+sub _pad ($s, $target, $pad, $at_start) {
+    $pad = ' ' unless defined $pad;
+    $pad = "$pad";
+    return $s if $pad eq '';
+    my $len = length $s;
+    my $t   = int($target // 0);
+    return $s if $len >= $t;
+    my $need = $t - $len;
+    # Repeat enough copies to cover $need, then trim to exactly $need.
+    my $fill = substr($pad x (int($need / length($pad)) + 1), 0, $need);
+    return $at_start ? $fill . $s : $s . $fill;
+}
+
+sub pad_start ($self, $recv, $target, $pad = undef) {
+    my $s = defined $recv && !ref($recv) ? "$recv" : '';
+    return _pad($s, $target, $pad, 1);
+}
+
+sub pad_end ($self, $recv, $target, $pad = undef) {
+    my $s = defined $recv && !ref($recv) ? "$recv" : '';
+    return _pad($s, $target, $pad, 0);
+}
+
 # `Array.prototype.sort(cmp)` / `Array.prototype.toSorted(cmp)`
 # lowering (#1448 Tier B). Non-mutating — JS's mutate-vs-new
 # distinction is moot in SSR template context.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/mojolicious",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "description": "Mojolicious EP template adapter for BarefootJS - generates .html.ep files from IR",
   "type": "module",
   "main": "./dist/index.js",
@@ -52,14 +52,14 @@
     "directory": "packages/adapter-mojolicious"
   },
   "dependencies": {
-    "@barefootjs/shared": "0.5.2"
+    "@barefootjs/shared": "0.6.0"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0"
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.5.2",
+    "@barefootjs/jsx": "0.6.0",
     "typescript": "^5.0.0"
   }
 }

package/src/__tests__/mojo-adapter.test.ts

@@ -928,11 +928,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 (loop-chained + standalone).
 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'
@@ -955,6 +970,12 @@ describe('MojoAdapter - #1448 Tier A/B fixture-driven lowering pins', () => {
     { fixture: arrayAtFixture,          expect: 'bf->at($items, -1)' },
     { fixture: arrayConcatFixture,      expect: 'bf->concat($left, $right)' },
     { fixture: arraySliceFixture,       expect: 'bf->slice($items, 1, 3)' },
+    // #1448 full-arity — zero-arg defaults.
+    { fixture: arraySliceCopyFixture,   expect: 'bf->slice($items, 0, undef)' },
+    { fixture: arrayJoinDefaultFixture, expect: `join(',', @{$items})` },
+    // `.at()` → index 0; `.concat()` → the receiver (shallow copy).
+    { fixture: arrayAtDefaultFixture,   expect: 'bf->at($items, 0)' },
+    { fixture: arrayConcatCopyFixture,  expect: `join('|', @{$items})` },
     { fixture: arrayReverseFixture,     expect: 'bf->reverse($items)' },
     // .toReversed shares the helper with .reverse — pinning both
     // routings catches a future divergence between them.
@@ -962,6 +983,23 @@ describe('MojoAdapter - #1448 Tier A/B fixture-driven lowering pins', () => {
     { fixture: stringToLowerCaseFixture,expect: 'lc($value)' },
     { fixture: stringToUpperCaseFixture,expect: 'uc($value)' },
     { fixture: stringTrimFixture,       expect: 'bf->trim($value)' },
+    // #1448 Tier B — string → array. `.split(',')` lowers to
+    // `bf->split`, here chained into `.join('|')` so the array ref is
+    // observable (`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 (`% if`).
+    { fixture: stringStartsWithFixture, expect: 'bf->starts_with($value, $prefix)' },
+    { fixture: stringStartsWithPositionFixture, expect: `bf->starts_with($value, 'world', 6)` },
+    { fixture: stringEndsWithFixture,   expect: 'bf->ends_with($value, $suffix)' },
+    { fixture: stringEndsWithPositionFixture,   expect: `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. The loop-chained field cases
     // hoist into a `my $bf_iter_lN = bf->sort(...)` local; the
     // standalone primitive cases inline the call. Each comparison key
@@ -1065,15 +1103,21 @@ export function C() {
     { 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}' },
+    // 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). (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 routed through the AST / `isSupported` gate.
-    { name: 'split', expr: `name().split(",")`, badEmit: '->{split}' },
-    { name: 'startsWith', expr: `name().startsWith("a")`, badEmit: '->{startsWith}' },
-    { name: 'endsWith', expr: `name().endsWith("z")`, badEmit: '->{endsWith}' },
-    { name: 'replace', expr: `name().replace("a", "b")`, badEmit: '->{replace}' },
-    { name: 'repeat', expr: `name().repeat(3)`, badEmit: '->{repeat}' },
-    { name: 'padStart', expr: `name().padStart(5, "0")`, badEmit: '->{padStart}' },
-    { name: 'padEnd', expr: `name().padEnd(5, "0")`, badEmit: '->{padEnd}' },
+    // diagnostic; now routed through the AST / `isSupported` gate. 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 stays refused — pinned
+    // separately below). `charAt` is Tier C and stays refused entirely.
     { name: 'charAt', expr: `name().charAt(0)`, badEmit: '->{charAt}' },
   ]
   for (const { name, expr, badEmit } of unsupported) {
@@ -1118,24 +1162,43 @@ export function C(props: { config: string }) {
   })
 
   // 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
+  // jsx-to-ir) rather than lowering to a broken `->{charAt}` inside
   // the grep. 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 MojoAdapter() })
     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 it can't regress into a broken
+  // `->{replace}` emit 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 MojoAdapter() })
+    expect(result.errors?.some(e => e.code === 'BF101')).toBe(true)
+    const template = result.files?.find(f => f.path.endsWith('.html.ep'))?.content ?? ''
+    expect(template).not.toContain('->{replace}')
+  })
+
   // Tier B `.sort` / `.toSorted` follow-ups still refused with BF021.
   // The Mojo client-only loop placeholder is an empty element (the
   // client runtime repopulates it via the `bf-s` scope marker), so the
@@ -1172,7 +1235,9 @@ export function C() {
   // more `HASH ref` crash), so we assert the build error rather than a
   // render crash. Skipped on hosts without Mojolicious installed.
   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 {
@@ -1182,7 +1247,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 MojoAdapter(),

package/src/adapter/mojo-adapter.ts

@@ -1295,9 +1295,10 @@ function renderArrayMethod(
       // arr.join(sep) → join(sep, @{arr}). The default `${obj}->{join}`
       // hash-lookup fallback would emit invalid Perl, which is why the
       // IR carves out a dedicated method node instead of routing
-      // through the generic call dispatcher.
+      // through the generic call dispatcher. `.join()` defaults the
+      // separator to `,` (JS) and ignores any extra argument.
       const obj = emit(object)
-      const sep = emit(args[0])
+      const sep = args.length >= 1 ? emit(args[0]) : `','`
       return `join(${sep}, @{${obj}})`
     }
     case 'includes': {
@@ -1333,9 +1334,10 @@ function renderArrayMethod(
       // `.at(i)` with negative-index support — `.at(-1)` is the
       // last element. The Mojo helper wraps the same `length + i`
       // arithmetic the Go `bf_at` does so the lowering stays
-      // symmetric across adapters.
+      // symmetric across adapters. `.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(${obj}, ${idx})`
     }
     case 'concat': {
@@ -1343,20 +1345,26 @@ function renderArrayMethod(
       // ref so the result composes with `.join(...)` / other
       // array-shape methods downstream (the canonical Tier A
       // conformance fixture chains `.concat(...).join(' ')`).
+      // `.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(${a}, ${b})`
     }
     case 'slice': {
-      // `.slice(start)` / `.slice(start, end)`. The Mojo helper
-      // mirrors the Go arithmetic (negative-index normalisation,
-      // out-of-bounds clamping, empty result on start >= end).
-      // Absent `end` lowers as `undef`, which the helper treats as
-      // "to length". Returns a new ARRAY ref so the result composes
-      // with `.join(...)` downstream.
+      // `.slice()` / `.slice(start)` / `.slice(start, end)`. The Mojo
+      // helper mirrors the Go arithmetic (negative-index normalisation,
+      // out-of-bounds clamping, empty result on start >= end). A
+      // missing `start` defaults to 0 (full copy); an absent `end`
+      // lowers as `undef`, which the helper treats as "to length". JS
+      // ignores a third+ argument. Returns a new ARRAY ref so the
+      // result composes with `.join(...)` downstream.
       const recv = emit(object)
-      const start = emit(args[0])
-      const end = args.length === 2 ? emit(args[1]) : 'undef'
+      const start = args.length >= 1 ? emit(args[0]) : '0'
+      const end = args.length >= 2 ? emit(args[1]) : 'undef'
       return `bf->slice(${recv}, ${start}, ${end})`
     }
     case 'reverse':
@@ -1388,6 +1396,86 @@ function renderArrayMethod(
       const recv = emit(object)
       return `bf->trim(${recv})`
     }
+    case 'split': {
+      // `.split()` / `.split(sep)` / `.split(sep, limit)` — string →
+      // ARRAY ref via `bf->split`. With no separator the helper returns
+      // the whole string as a single element; otherwise it quotemetas
+      // the separator (literal match, not regex) and keeps trailing
+      // empties (`-1`), staying byte-equal with Go's `bf_split`. The
+      // optional `limit` caps the pieces; JS ignores a third+ argument.
+      // See #1448 Tier B.
+      const recv = emit(object)
+      if (args.length === 0) {
+        return `bf->split(${recv})`
+      }
+      const sep = emit(args[0])
+      if (args.length === 1) {
+        return `bf->split(${recv}, ${sep})`
+      }
+      const limit = emit(args[1])
+      return `bf->split(${recv}, ${sep}, ${limit})`
+    }
+    case 'startsWith':
+    case 'endsWith': {
+      // `.startsWith(prefix, position?)` / `.endsWith(suffix,
+      // endPosition?)` — string → boolean. The Perl helpers
+      // (`bf->starts_with` / `bf->ends_with`) do a `substr`-anchored
+      // comparison so the search string is matched literally (no regex
+      // metachar surprises) and undef receivers stay quiet. The optional
+      // second argument re-anchors the test; JS ignores a third+
+      // argument. See #1448 Tier B.
+      const fn = method === 'startsWith' ? 'starts_with' : 'ends_with'
+      const recv = emit(object)
+      const arg = emit(args[0])
+      if (args.length >= 2) {
+        return `bf->${fn}(${recv}, ${arg}, ${emit(args[1])})`
+      }
+      return `bf->${fn}(${recv}, ${arg})`
+    }
+    case 'replace': {
+      // `.replace(old, new)` — string-pattern form, first occurrence.
+      // The `bf->replace` helper splices via index/substr (not `s///`)
+      // so both the pattern and the replacement are literal — no Perl
+      // regex metacharacters and no `$1` / `$&` interpolation in the
+      // replacement, keeping it byte-equal with Go's `bf_replace`. 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(${recv}, ${oldS}, ${newS})`
+    }
+    case 'repeat': {
+      // `.repeat(n)` — string repeated `n` times. The `bf->repeat`
+      // helper wraps Perl's `x` operator with the same negative-count
+      // → "" clamp and integer truncation Go's `bf_repeat` applies, so
+      // the two adapters stay byte-equal. 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(${recv}, ${count})`
+    }
+    case 'padStart':
+    case 'padEnd': {
+      // `.padStart(target, pad?)` / `.padEnd(target, pad?)`. The
+      // `bf->pad_*` helpers default the pad to a single space when the
+      // arg is omitted and measure length in characters, matching Go's
+      // rune-based `bf_pad_*`. 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' ? 'pad_start' : 'pad_end'
+      const recv = emit(object)
+      if (args.length === 0) {
+        return `bf->${fn}(${recv}, 0)`
+      }
+      const target = emit(args[0])
+      if (args.length === 1) {
+        return `bf->${fn}(${recv}, ${target})`
+      }
+      const pad = emit(args[1])
+      return `bf->${fn}(${recv}, ${target}, ${pad})`
+    }
     default: {
       // TS-level exhaustiveness guard. If this throws at runtime, the
       // IR was constructed against a newer `ArrayMethod` variant that