@barefootjs/mojolicious 0.6.0 → 0.6.1

package/dist/adapter/index.js

@@ -884,6 +884,25 @@ function renderSortMethod(recv, c) {
   });
   return `bf->sort(${recv}, { keys => [${keyHashes.join(", ")}] })`;
 }
+function renderReduceMethod(recv, op, direction) {
+  const keyEntry = op.key.kind === "self" ? `key_kind => 'self'` : `key_kind => 'field', key => '${op.key.field}'`;
+  const init = op.type === "string" ? `'${op.init.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'` : op.init;
+  return `bf->reduce(${recv}, { op => '${op.op}', ${keyEntry}, type => '${op.type}', init => ${init}, direction => '${direction}' })`;
+}
+function renderFlatMethod(recv, depth) {
+  const d = depth === "infinity" ? -1 : depth;
+  return `bf->flat(${recv}, ${d})`;
+}
+function renderFlatMapMethod(recv, op) {
+  const proj = op.projection;
+  if (proj.kind === "tuple") {
+    const specs = proj.elements.map((l) => l.kind === "self" ? `['self', '']` : `['field', '${l.field}']`).join(", ");
+    return `bf->flat_map_tuple(${recv}, ${specs})`;
+  }
+  if (proj.kind === "self")
+    return `bf->flat_map(${recv}, 'self', '')`;
+  return `bf->flat_map(${recv}, 'field', '${proj.field}')`;
+}
 function isStringTypeInfo(type) {
   return type?.kind === "primitive" && type.primitive === "string";
 }
@@ -1008,6 +1027,15 @@ class MojoFilterEmitter {
   sortMethod(_method, object, comparator, emit) {
     return renderSortMethod(emit(object), comparator);
   }
+  reduceMethod(method, object, reduceOp, emit) {
+    return renderReduceMethod(emit(object), reduceOp, method === "reduceRight" ? "right" : "left");
+  }
+  flatMethod(object, depth, emit) {
+    return renderFlatMethod(emit(object), depth);
+  }
+  flatMapMethod(object, op, emit) {
+    return renderFlatMapMethod(emit(object), op);
+  }
   conditional(_test, _consequent, _alternate) {
     return "1";
   }
@@ -1129,6 +1157,15 @@ class MojoTopLevelEmitter {
   sortMethod(_method, object, comparator, emit) {
     return renderSortMethod(emit(object), comparator);
   }
+  reduceMethod(method, object, reduceOp, emit) {
+    return renderReduceMethod(emit(object), reduceOp, method === "reduceRight" ? "right" : "left");
+  }
+  flatMethod(object, depth, emit) {
+    return renderFlatMethod(emit(object), depth);
+  }
+  flatMapMethod(object, op, emit) {
+    return renderFlatMapMethod(emit(object), op);
+  }
   conditional(test, consequent, alternate, emit) {
     return `(${emit(test)} ? ${emit(consequent)} : ${emit(alternate)})`;
   }

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

@@ -884,6 +884,25 @@ function renderSortMethod(recv, c) {
   });
   return `bf->sort(${recv}, { keys => [${keyHashes.join(", ")}] })`;
 }
+function renderReduceMethod(recv, op, direction) {
+  const keyEntry = op.key.kind === "self" ? `key_kind => 'self'` : `key_kind => 'field', key => '${op.key.field}'`;
+  const init = op.type === "string" ? `'${op.init.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'` : op.init;
+  return `bf->reduce(${recv}, { op => '${op.op}', ${keyEntry}, type => '${op.type}', init => ${init}, direction => '${direction}' })`;
+}
+function renderFlatMethod(recv, depth) {
+  const d = depth === "infinity" ? -1 : depth;
+  return `bf->flat(${recv}, ${d})`;
+}
+function renderFlatMapMethod(recv, op) {
+  const proj = op.projection;
+  if (proj.kind === "tuple") {
+    const specs = proj.elements.map((l) => l.kind === "self" ? `['self', '']` : `['field', '${l.field}']`).join(", ");
+    return `bf->flat_map_tuple(${recv}, ${specs})`;
+  }
+  if (proj.kind === "self")
+    return `bf->flat_map(${recv}, 'self', '')`;
+  return `bf->flat_map(${recv}, 'field', '${proj.field}')`;
+}
 function isStringTypeInfo(type) {
   return type?.kind === "primitive" && type.primitive === "string";
 }
@@ -1008,6 +1027,15 @@ class MojoFilterEmitter {
   sortMethod(_method, object, comparator, emit) {
     return renderSortMethod(emit(object), comparator);
   }
+  reduceMethod(method, object, reduceOp, emit) {
+    return renderReduceMethod(emit(object), reduceOp, method === "reduceRight" ? "right" : "left");
+  }
+  flatMethod(object, depth, emit) {
+    return renderFlatMethod(emit(object), depth);
+  }
+  flatMapMethod(object, op, emit) {
+    return renderFlatMapMethod(emit(object), op);
+  }
   conditional(_test, _consequent, _alternate) {
     return "1";
   }
@@ -1129,6 +1157,15 @@ class MojoTopLevelEmitter {
   sortMethod(_method, object, comparator, emit) {
     return renderSortMethod(emit(object), comparator);
   }
+  reduceMethod(method, object, reduceOp, emit) {
+    return renderReduceMethod(emit(object), reduceOp, method === "reduceRight" ? "right" : "left");
+  }
+  flatMethod(object, depth, emit) {
+    return renderFlatMethod(emit(object), depth);
+  }
+  flatMapMethod(object, op, emit) {
+    return renderFlatMapMethod(emit(object), op);
+  }
   conditional(test, consequent, alternate, emit) {
     return `(${emit(test)} ? ${emit(consequent)} : ${emit(alternate)})`;
   }

package/dist/index.js

@@ -884,6 +884,25 @@ function renderSortMethod(recv, c) {
   });
   return `bf->sort(${recv}, { keys => [${keyHashes.join(", ")}] })`;
 }
+function renderReduceMethod(recv, op, direction) {
+  const keyEntry = op.key.kind === "self" ? `key_kind => 'self'` : `key_kind => 'field', key => '${op.key.field}'`;
+  const init = op.type === "string" ? `'${op.init.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'` : op.init;
+  return `bf->reduce(${recv}, { op => '${op.op}', ${keyEntry}, type => '${op.type}', init => ${init}, direction => '${direction}' })`;
+}
+function renderFlatMethod(recv, depth) {
+  const d = depth === "infinity" ? -1 : depth;
+  return `bf->flat(${recv}, ${d})`;
+}
+function renderFlatMapMethod(recv, op) {
+  const proj = op.projection;
+  if (proj.kind === "tuple") {
+    const specs = proj.elements.map((l) => l.kind === "self" ? `['self', '']` : `['field', '${l.field}']`).join(", ");
+    return `bf->flat_map_tuple(${recv}, ${specs})`;
+  }
+  if (proj.kind === "self")
+    return `bf->flat_map(${recv}, 'self', '')`;
+  return `bf->flat_map(${recv}, 'field', '${proj.field}')`;
+}
 function isStringTypeInfo(type) {
   return type?.kind === "primitive" && type.primitive === "string";
 }
@@ -1008,6 +1027,15 @@ class MojoFilterEmitter {
   sortMethod(_method, object, comparator, emit) {
     return renderSortMethod(emit(object), comparator);
   }
+  reduceMethod(method, object, reduceOp, emit) {
+    return renderReduceMethod(emit(object), reduceOp, method === "reduceRight" ? "right" : "left");
+  }
+  flatMethod(object, depth, emit) {
+    return renderFlatMethod(emit(object), depth);
+  }
+  flatMapMethod(object, op, emit) {
+    return renderFlatMapMethod(emit(object), op);
+  }
   conditional(_test, _consequent, _alternate) {
     return "1";
   }
@@ -1129,6 +1157,15 @@ class MojoTopLevelEmitter {
   sortMethod(_method, object, comparator, emit) {
     return renderSortMethod(emit(object), comparator);
   }
+  reduceMethod(method, object, reduceOp, emit) {
+    return renderReduceMethod(emit(object), reduceOp, method === "reduceRight" ? "right" : "left");
+  }
+  flatMethod(object, depth, emit) {
+    return renderFlatMethod(emit(object), depth);
+  }
+  flatMapMethod(object, op, emit) {
+    return renderFlatMapMethod(emit(object), op);
+  }
   conditional(test, consequent, alternate, emit) {
     return `(${emit(test)} ? ${emit(consequent)} : ${emit(alternate)})`;
   }

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`
@@ -782,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.6.0",
+  "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.6.0"
+    "@barefootjs/shared": "0.6.1"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0"
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.6.0",
+    "@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) {
@@ -960,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 = [
@@ -1020,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) {
@@ -1041,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
 // =============================================================================
@@ -1099,10 +1190,14 @@ 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

package/src/adapter/mojo-adapter.ts

@@ -56,7 +56,7 @@ import { isAriaBooleanAttr, isBooleanResultExpr } from './boolean-result'
  * the `IRNodeEmitter` interface.
  */
 type MojoRenderCtx = Record<string, never>
-import type { ParsedExpr, ParsedStatement, SortComparator, TemplatePart } from '@barefootjs/jsx'
+import type { ParsedExpr, ParsedStatement, SortComparator, ReduceOp, FlatDepth, FlatMapOp, TemplatePart } from '@barefootjs/jsx'
 import { BF_SLOT, BF_COND } from '@barefootjs/shared'
 
 interface PrimitiveSpec {
@@ -1533,6 +1533,64 @@ function renderSortMethod(recv: string, c: SortComparator): string {
   return `bf->sort(${recv}, { keys => [${keyHashes.join(', ')}] })`
 }
 
+/**
+ * Render a `.reduce(fn, init)` arithmetic fold (#1448 Tier C) as a
+ * `bf->reduce(...)` call. The structured `ReduceOp` maps to the Perl
+ * helper's options hash:
+ *
+ *   bf->reduce($recv, { op => '+', key_kind => 'field', key => 'duration',
+ *                       type => 'numeric', init => 0 })
+ *
+ * A numeric init passes through as a bare Perl number (`0`, `-1`); a
+ * string init (concat fold) is re-quoted from its literal contents.
+ */
+function renderReduceMethod(recv: string, op: ReduceOp, direction: 'left' | 'right'): string {
+  const keyEntry =
+    op.key.kind === 'self'
+      ? `key_kind => 'self'`
+      : `key_kind => 'field', key => '${op.key.field}'`
+  // `op.init` is the decoded seed value. A numeric seed is already a
+  // canonical decimal literal Perl reads directly; a concat seed is the
+  // string contents, embedded in a single-quoted Perl literal. The `'`
+  // escape is REQUIRED: a seed decoded from a double-quoted JS literal
+  // (e.g. `"a'b"`) is escape-free yet contains an apostrophe. A literal
+  // backslash can't occur (it would need a `\\` escape, which the parser
+  // refuses), but escaping it too keeps this self-contained.
+  const init =
+    op.type === 'string'
+      ? `'${op.init.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`
+      : op.init
+  // `direction` is "left" (reduce) or "right" (reduceRight); the Perl
+  // helper reverses the list for "right". Only observable for concat.
+  return `bf->reduce(${recv}, { op => '${op.op}', ${keyEntry}, type => '${op.type}', init => ${init}, direction => '${direction}' })`
+}
+
+// `.flat(depth?)` → `bf->flat($recv, $depth)`. The `Infinity` form lowers
+// to the `-1` sentinel (flatten fully); a finite depth flattens that many
+// levels (`0` = shallow copy). See `sub flat` in BarefootJS.pm. (#1448)
+function renderFlatMethod(recv: string, depth: FlatDepth): string {
+  const d = depth === 'infinity' ? -1 : depth
+  return `bf->flat(${recv}, ${d})`
+}
+
+// `.flatMap(i => i)` / `.flatMap(i => i.field)` → `bf->flat_map($recv,
+// 'self'|'field', 'field')`, and the array-literal tuple form
+// `i => [i.a, i.b]` → `bf->flat_map_tuple($recv, ['field','a'], ...)`
+// (one arrayref per leaf). The field key is the raw JS prop name (Perl
+// hashes are keyed by it), mirroring `bf->reduce`. See `sub flat_map` /
+// `sub flat_map_tuple` in BarefootJS.pm.
+function renderFlatMapMethod(recv: string, op: FlatMapOp): string {
+  const proj = op.projection
+  if (proj.kind === 'tuple') {
+    const specs = proj.elements
+      .map(l => (l.kind === 'self' ? `['self', '']` : `['field', '${l.field}']`))
+      .join(', ')
+    return `bf->flat_map_tuple(${recv}, ${specs})`
+  }
+  if (proj.kind === 'self') return `bf->flat_map(${recv}, 'self', '')`
+  return `bf->flat_map(${recv}, 'field', '${proj.field}')`
+}
+
 /** True when `type` is the `string` primitive. */
 function isStringTypeInfo(type: TypeInfo | undefined): boolean {
   return type?.kind === 'primitive' && type.primitive === 'string'
@@ -1715,6 +1773,18 @@ class MojoFilterEmitter implements ParsedExprEmitter {
     return renderSortMethod(emit(object), comparator)
   }
 
+  reduceMethod(method: 'reduce' | 'reduceRight', object: ParsedExpr, reduceOp: ReduceOp, emit: (e: ParsedExpr) => string): string {
+    return renderReduceMethod(emit(object), reduceOp, method === 'reduceRight' ? 'right' : 'left')
+  }
+
+  flatMethod(object: ParsedExpr, depth: FlatDepth, emit: (e: ParsedExpr) => string): string {
+    return renderFlatMethod(emit(object), depth)
+  }
+
+  flatMapMethod(object: ParsedExpr, op: FlatMapOp, emit: (e: ParsedExpr) => string): string {
+    return renderFlatMapMethod(emit(object), op)
+  }
+
   conditional(_test: ParsedExpr, _consequent: ParsedExpr, _alternate: ParsedExpr): string {
     return '1'
   }
@@ -1896,6 +1966,18 @@ class MojoTopLevelEmitter implements ParsedExprEmitter {
     return renderSortMethod(emit(object), comparator)
   }
 
+  reduceMethod(method: 'reduce' | 'reduceRight', object: ParsedExpr, reduceOp: ReduceOp, emit: (e: ParsedExpr) => string): string {
+    return renderReduceMethod(emit(object), reduceOp, method === 'reduceRight' ? 'right' : 'left')
+  }
+
+  flatMethod(object: ParsedExpr, depth: FlatDepth, emit: (e: ParsedExpr) => string): string {
+    return renderFlatMethod(emit(object), depth)
+  }
+
+  flatMapMethod(object: ParsedExpr, op: FlatMapOp, emit: (e: ParsedExpr) => string): string {
+    return renderFlatMapMethod(emit(object), op)
+  }
+
   conditional(
     test: ParsedExpr,
     consequent: ParsedExpr,