@barefootjs/mojolicious 0.5.3 → 0.6.1

package/lib/BarefootJS.pm

@@ -508,6 +508,71 @@ sub reverse ($self, $recv) {
     return [ reverse @$recv ];
 }
 
+# `Array.prototype.flat(depth?)` (#1448 Tier C) — flatten nested ARRAY
+# refs `$depth` levels deep. A `$depth` of -1 is the `Infinity` sentinel
+# (flatten fully); 0 returns a shallow copy. Non-ARRAY elements are kept
+# as-is (JS only flattens nested arrays). Non-ARRAY receiver → [].
+sub flat ($self, $recv, $depth = 1) {
+    return [] unless ref($recv) eq 'ARRAY';
+    my @out;
+    for my $el (@$recv) {
+        if ($depth != 0 && ref($el) eq 'ARRAY') {
+            my $next = $depth > 0 ? $depth - 1 : $depth;
+            push @out, @{ $self->flat($el, $next) };
+        }
+        else {
+            push @out, $el;
+        }
+    }
+    return \@out;
+}
+
+# `Array.prototype.flatMap(fn)` value-returning field projection
+# (#1448 Tier C) — map each element through a self / field projection,
+# then flatten one level. `field` reads a HASH-ref key (the raw JS prop
+# name, as `bf->reduce` does); a projected non-ARRAY value is kept as-is
+# (flatMap = map + flat(1)). Non-ARRAY receiver → [].
+sub flat_map ($self, $recv, $key_kind, $key) {
+    return [] unless ref($recv) eq 'ARRAY';
+    my @projected;
+    for my $el (@$recv) {
+        if ($key_kind eq 'field') {
+            # JS `i => i.field` on a non-object yields `undefined`, not the
+            # element itself — push `undef` so a scalar element doesn't leak
+            # into the output (matches Go's `getFieldValue` returning nil).
+            push @projected, ref($el) eq 'HASH' ? $el->{$key} : undef;
+        }
+        else {
+            push @projected, $el;
+        }
+    }
+    return $self->flat(\@projected, 1);
+}
+
+# `Array.prototype.flatMap(i => [i.a, i.b])` — array-literal tuple
+# projection (#1448 Tier C). Each `@specs` entry is a [kind, key] arrayref
+# (['self', ''] or ['field', 'a']). For each element, every leaf's value
+# is appended in order. flat(1) removes only the literal wrapper, so an
+# array-valued leaf is appended verbatim (no spread) — i.e. just append
+# each leaf. A non-HASH element under a `field` leaf yields undef (JS
+# `i.field` on a non-object). Non-ARRAY receiver → [].
+sub flat_map_tuple ($self, $recv, @specs) {
+    return [] unless ref($recv) eq 'ARRAY';
+    my @out;
+    for my $el (@$recv) {
+        for my $spec (@specs) {
+            my ($kind, $key) = @$spec;
+            if ($kind eq 'field') {
+                push @out, ref($el) eq 'HASH' ? $el->{$key} : undef;
+            }
+            else {
+                push @out, $el;
+            }
+        }
+    }
+    return \@out;
+}
+
 # `String.prototype.trim()` — strip leading + trailing whitespace.
 # JS's `String.prototype.trim` matches `\s` in the Unicode sense
 # (any whitespace including non-breaking space U+00A0); Perl's `\s`
@@ -526,6 +591,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.
@@ -616,6 +847,63 @@ sub _compare_sort_key ($av, $bv, $compare_type) {
     return ($av // 0) <=> ($bv // 0);    # numeric
 }
 
+# Fold an array into a scalar via the arithmetic-fold catalogue
+# (#1448 Tier C). Mirrors Go's `bf_reduce` and JS `reduce(fn, init)` /
+# `reduceRight(fn, init)` for the shapes `(acc, x) => acc <op> x` /
+# `(acc, x) => acc <op> x.field`:
+#
+#   bf->reduce($recv, {
+#     op        => '+' | '*',
+#     key_kind  => 'self' | 'field',
+#     key       => '<field>',         # when key_kind eq 'field'
+#     type      => 'numeric' | 'string',
+#     init      => <seed>,            # number, or string for concat
+#     direction => 'left' | 'right',  # 'right' = reduceRight (default 'left')
+#   })
+#
+# Numeric folds accumulate with `+` / `*` (non-numeric keys coalesce to
+# 0); string folds concatenate via `bf->string` (undef → ''). The init
+# seeds the accumulator, so an empty array returns it unchanged — exactly
+# like JS. `direction => 'right'` folds right-to-left (reduceRight); only
+# observable for string concat, since numeric sum / product commute.
+# Float stringification can diverge from Go's for inexact binary
+# fractions (e.g. 0.1 + 0.2); integer sums — the common case — agree.
+sub reduce ($self, $recv, $opts = {}) {
+    my $op        = $opts->{op}        // '+';
+    my $key_kind  = $opts->{key_kind}  // 'self';
+    my $key       = $opts->{key}       // '';
+    my $type      = $opts->{type}      // 'numeric';
+    my $direction = $opts->{direction} // 'left';
+
+    my @items = ref($recv) eq 'ARRAY' ? @$recv : ();
+    # reduceRight folds right-to-left; reversing the snapshot keeps the
+    # single forward loop below. Only observable for string concat —
+    # numeric sum / product commute. Qualify as CORE::reverse — this
+    # package defines `sub reverse` (the `.reverse()` helper), so a bare
+    # `reverse` is ambiguous under `use warnings`.
+    @items = CORE::reverse(@items) if $direction eq 'right';
+    my $project = sub ($item) {
+        $key_kind eq 'field' && ref($item) eq 'HASH' ? $item->{$key} : $item;
+    };
+
+    if ($type eq 'string') {
+        my $acc = $opts->{init} // '';
+        $acc .= $self->string($project->($_)) for @items;
+        return $acc;
+    }
+
+    my $acc = $opts->{init} // 0;
+    for my $item (@items) {
+        my $n = $project->($item);
+        # Guard `defined` before `looks_like_number` so a missing field
+        # (undef) folds as 0 without an "uninitialized value" warning
+        # under `use warnings` — matching the `$av // ''` style `sort` uses.
+        $n = 0 unless defined $n && looks_like_number($n);
+        $op eq '*' ? ($acc *= $n) : ($acc += $n);
+    }
+    return $acc;
+}
+
 # ---------------------------------------------------------------------------
 # JSX intrinsic-element spread (#1407)
 # ---------------------------------------------------------------------------

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/mojolicious",
-  "version": "0.5.3",
+  "version": "0.6.1",
   "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.3"
+    "@barefootjs/shared": "0.6.1"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0"
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.5.3",
+    "@barefootjs/jsx": "0.6.1",
     "typescript": "^5.0.0"
   }
 }

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

@@ -395,9 +395,16 @@ export function C() {
     // The nested-higher-order-in-filter-predicate shape also lowers
     // now (#1443 PR4) — moved to a positive-output test below.
     const cases: { name: string; body: string; needle: string }[] = [
-      { name: 'reduce',            body: `<div>{items().reduce((s, x) => s + x, 0)}</div>`,                                                          needle: '.reduce(' },
+      // The arithmetic-fold `.reduce(fn, init)` catalogue now lowers
+      // (positive-output tests below + the reduce-* conformance
+      // fixtures); the no-init form stays refused — JS throws on an
+      // empty array there, which a template can't mirror.
+      { name: 'reduce (no init)',  body: `<div>{items().reduce((s, x) => s + x)}</div>`,                                                             needle: '.reduce(' },
       { name: 'forEach',           body: `<ul>{items().forEach(x => x)}</ul>`,                                                                       needle: '.forEach(' },
-      { name: 'flatMap',           body: `<ul>{items().flatMap(x => x.tags).map(t => <li key={t}>{t}</li>)}</ul>`,                                  needle: '.flatMap(' },
+      // Self / field / field-tuple `.flatMap` now lowers (#1448 Tier C) —
+      // even as a loop base — so those moved to positive tests below. A
+      // tuple with a non-leaf element (a string literal) stays refused.
+      { name: 'flatMap (literal element)', body: `<div>{items().flatMap(x => [x.tag, "x"])}</div>`,                                                needle: '.flatMap(' },
     ]
 
     for (const { name, body, needle } of cases) {
@@ -928,11 +935,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'
@@ -945,6 +967,12 @@ import { fixture as arrayToSortedFixture } from '../../../adapter-tests/fixtures
 import { fixture as arrayEntriesFixture } from '../../../adapter-tests/fixtures/methods/array-entries'
 import { fixture as arrayKeysFixture } from '../../../adapter-tests/fixtures/methods/array-keys'
 import { fixture as arrayValuesFixture } from '../../../adapter-tests/fixtures/methods/array-values'
+// #1448 Tier C — .reduce(fn, init) arithmetic-fold catalogue.
+import { fixture as reduceSumFieldFixture } from '../../../adapter-tests/fixtures/methods/reduce-sum-field'
+import { fixture as reduceSumSelfFixture } from '../../../adapter-tests/fixtures/methods/reduce-sum-self'
+import { fixture as reduceConcatFixture } from '../../../adapter-tests/fixtures/methods/reduce-concat'
+import { fixture as reduceProductFixture } from '../../../adapter-tests/fixtures/methods/reduce-product'
+import { fixture as reduceRightConcatFixture } from '../../../adapter-tests/fixtures/methods/reduce-right-concat'
 
 describe('MojoAdapter - #1448 Tier A/B fixture-driven lowering pins', () => {
   const cases = [
@@ -955,6 +983,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 +996,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
@@ -982,6 +1033,17 @@ describe('MojoAdapter - #1448 Tier A/B fixture-driven lowering pins', () => {
     { fixture: arrayKeysFixture,          expect: '% for my $k (0..$#{$items})' },
     // .values() → standard for loop (same as plain .map())
     { fixture: arrayValuesFixture,        expect: '% my $v = $items->[$_i];' },
+    // #1448 Tier C — .reduce(fn, init) arithmetic fold. The structured
+    // ReduceOp lowers to a single `bf->reduce(...)` call with op /
+    // key / type / init / direction in the options hash. Each shape
+    // exercises one arm: field-numeric sum, self-numeric sum,
+    // string-concat fold, the product (`*`) operator, and the
+    // right-to-left `direction` of reduceRight.
+    { fixture: reduceSumFieldFixture,     expect: `bf->reduce($items, { op => '+', key_kind => 'field', key => 'duration', type => 'numeric', init => 0, direction => 'left' })` },
+    { fixture: reduceSumSelfFixture,      expect: `bf->reduce($nums, { op => '+', key_kind => 'self', type => 'numeric', init => 0, direction => 'left' })` },
+    { fixture: reduceConcatFixture,       expect: `bf->reduce($items, { op => '+', key_kind => 'field', key => 'label', type => 'string', init => '', direction => 'left' })` },
+    { fixture: reduceProductFixture,      expect: `bf->reduce($items, { op => '*', key_kind => 'field', key => 'qty', type => 'numeric', init => 1, direction => 'left' })` },
+    { fixture: reduceRightConcatFixture,  expect: `bf->reduce($items, { op => '+', key_kind => 'field', key => 'label', type => 'string', init => '', direction => 'right' })` },
   ]
 
   for (const { fixture, expect: expectedHelper } of cases) {
@@ -1003,6 +1065,73 @@ describe('MojoAdapter - #1448 Tier A/B fixture-driven lowering pins', () => {
   }
 })
 
+describe('MojoAdapter - #1448 Tier C .flat(depth?)', () => {
+  function emitFlat(expr: string): string {
+    const a = new MojoAdapter()
+    const ir = compileToIR(`
+function C({ rows }: { rows: number[][] }) {
+  return <div>{${expr}}</div>
+}
+export { C }
+`, a)
+    return a.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('MojoAdapter - #1448 Tier C .flatMap(field projection)', () => {
+  function emitFlatMap(expr: string): string {
+    const a = new MojoAdapter()
+    const ir = compileToIR(`
+function C({ rows }: { rows: { a: string; b: string; tags: string[] }[] }) {
+  return <div>{${expr}}</div>
+}
+export { C }
+`, a)
+    return a.generate(ir).template ?? ''
+  }
+
+  test('.flatMap(i => i.field) emits bf->flat_map with the raw field key', () => {
+    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 leaf specs', () => {
+    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'])`)
+  })
+
+  test('field-projection flatMap as a loop base lowers (no BF101)', () => {
+    const a = new MojoAdapter()
+    const ir = compileToIR(`'use client'
+import { createSignal } from '@barefootjs/client'
+export function C() {
+  const [items] = createSignal<{ tags: string[] }[]>([])
+  return <ul>{items().flatMap(x => x.tags).map(t => <li key={t}>{t}</li>)}</ul>
+}`, a)
+    const template = a.generate(ir).template ?? ''
+    expect((a.errors ?? []).filter(e => e.code === 'BF101')).toEqual([])
+    expect(template).toContain(`bf->flat_map($items, 'field', 'tags')`)
+  })
+})
+
 // =============================================================================
 // #1448 — `/* @client */` escape hatch for STILL-UNSUPPORTED methods
 // =============================================================================
@@ -1061,19 +1190,29 @@ export function C() {
   // Perl 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). (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,22 +1257,41 @@ 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.
@@ -1172,7 +1330,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 +1342,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(),