@barefootjs/mojolicious 0.16.0 → 0.17.0

package/dist/test-render.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-render.d.ts","sourceRoot":"","sources":["../src/test-render.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAeH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKxE;AAkCD,MAAM,WAAW,aAAa;IAC5B,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,8BAA8B;IAC9B,OAAO,EAAE,OAAO,iBAAiB,EAAE,eAAe,CAAA;IAClD,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAgNjF;AAmWD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAuBT"}
+{"version":3,"file":"test-render.d.ts","sourceRoot":"","sources":["../src/test-render.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAeH,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,YAAY,OAAO,EAAE,MAAM,EAG1B;CACF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKxE;AAkCD,MAAM,WAAW,aAAa;IAC5B,sBAAsB;IACtB,MAAM,EAAE,MAAM,CAAA;IACd,8BAA8B;IAC9B,OAAO,EAAE,OAAO,iBAAiB,EAAE,eAAe,CAAA;IAClD,iCAAiC;IACjC,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC/B,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;CACvB;AAED,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC,CAgNjF;AAqWD;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAuBT"}

package/lib/BarefootJS/Backend/Mojo.pm

@@ -1,5 +1,5 @@
 package BarefootJS::Backend::Mojo;
-our $VERSION = "0.15.2";
+our $VERSION = "0.16.0";
 use Mojo::Base -base, -signatures;
 
 use Mojo::ByteStream qw(b);

package/lib/Mojolicious/Plugin/BarefootJS/DevReload.pm

@@ -1,5 +1,5 @@
 package Mojolicious::Plugin::BarefootJS::DevReload;
-our $VERSION = "0.15.2";
+our $VERSION = "0.16.0";
 use Mojo::Base 'Mojolicious::Plugin', -signatures;
 
 =head1 NAME

package/lib/Mojolicious/Plugin/BarefootJS.pm

@@ -1,5 +1,5 @@
 package Mojolicious::Plugin::BarefootJS;
-our $VERSION = "0.15.2";
+our $VERSION = "0.16.0";
 use Mojo::Base 'Mojolicious::Plugin', -signatures;
 
 use Mojo::File qw(path);

package/package.json

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

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

@@ -122,8 +122,8 @@ runAdapterConformanceTests({
     // (Go) and new `bf->trim` helper (Mojo) handle the strip
     // (#1448 Tier A ninth PR, closing out Tier A).
     // `.find` / `.findIndex` / `.findLast` / `.findLastIndex` are no longer
-    // pinned — the Mojo `higherOrder` emitter now lowers them to the runtime
-    // `bf->find` / `find_index` / `find_last` / `find_last_index` helpers
+    // pinned — the Mojo `callbackMethod` predicate arm now lowers them to the
+    // runtime `bf->find` / `find_index` / `find_last` / `find_last_index` helpers
     // (per-element coderef predicate), matching Xslate. `.join` was never
     // pinned (handled by `renderArrayMethod`'s `case 'join'`).
   },
@@ -239,8 +239,9 @@ describe('MojoAdapter - searchParams() env-signal lowering (#1922)', () => {
   // generic hash deref `$searchParams->{get}` (which drops the arg).
   test('lowers searchParams().get(k) to a method call on $searchParams', () => {
     const { template } = compileAndGenerate(`
-import { searchParams } from '@barefootjs/client'
+import { createSearchParams } from '@barefootjs/client'
 function SortLabel() {
+  const [searchParams] = createSearchParams()
   return <p>{searchParams().get('sort') ?? 'none'}</p>
 }
 `)
@@ -248,13 +249,14 @@ function SortLabel() {
     expect(template).not.toContain('$searchParams->{get}')
   })
 
-  // An aliased import binds the env signal to a different local name; the
-  // expression reads `sp()`, but it still lowers to the canonical
+  // An aliased destructured getter binds the env signal to a different local
+  // name; the expression reads `sp()`, but it still lowers to the canonical
   // `$searchParams` reader (the harness/plugin seed that fixed var).
-  test('matches an aliased import (`searchParams as sp`) and emits canonical $searchParams', () => {
+  test('matches an aliased env-signal getter (`const [sp] = createSearchParams()`) and emits canonical $searchParams', () => {
     const { template } = compileAndGenerate(`
-import { searchParams as sp } from '@barefootjs/client'
+import { createSearchParams } from '@barefootjs/client'
 function SortLabel() {
+  const [sp] = createSearchParams()
   return <p>{sp().get('sort') ?? 'none'}</p>
 }
 `)
@@ -720,10 +722,12 @@ export function C() {
       // 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(' },
-      // 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(' },
+      // #2018 P5: an array-literal projection with a literal element
+      // (`x => [x.tag, "x"]`) now lowers through the runtime evaluator
+      // (`bf->flat_map_eval`) — the structured-tuple restriction that
+      // refused a non-`self`/`field` leaf is gone. See the positive
+      // flat_map_eval pins below. The remaining BF101 flatMap surface
+      // (a projection the evaluator can't serialize) has no example here.
     ]
 
     for (const { name, body, needle } of cases) {
@@ -760,7 +764,11 @@ export function C() {
 }`, 'C.tsx', { adapter })
     expect(result.errors?.filter(e => e.code === 'BF101') ?? []).toEqual([])
     const template = result.files.find(f => f.path.endsWith('.html.ep'))?.content ?? ''
-    expect(template).toContain('grep { $_->{done} } @{$items}')
+    // #2018 P2: the `.filter().map()` loop hoists over the filtered array,
+    // now produced by the evaluator (`bf->filter_eval`). (Hoisting the call
+    // into a single `my` var is a P3 optimization.)
+    expect(template).toContain('bf->filter_eval($items,')
+    expect(template).toContain('"property":"done"')
   })
 
   test('lowers nested .filter(...).length > 0 in outer filter predicate (#1443 PR4)', () => {
@@ -798,7 +806,11 @@ export function C() {
 }`, 'C.tsx', { adapter })
     expect(result.errors?.filter(e => e.code === 'BF101') ?? []).toEqual([])
     const template = result.files.find(f => f.path.endsWith('.html.ep'))?.content ?? ''
-    expect(template).toContain('grep { $_->{done} } @{$items}')
+    // #2018 P2: the `.filter().map()` loop hoists over the filtered array,
+    // now produced by the evaluator (`bf->filter_eval`). (Hoisting the call
+    // into a single `my` var is a P3 optimization.)
+    expect(template).toContain('bf->filter_eval($items,')
+    expect(template).toContain('"property":"done"')
   })
 
   test('lowers the registry Slot\'s [a, b].filter(Boolean).join(\' \') chain (#1443)', () => {
@@ -977,17 +989,18 @@ export { A }`, 'A.tsx', { adapter })
     expect(template).not.toContain('$bf->trim')
   })
 
-  test('lowers .find / .findIndex / .findLast / .findLastIndex via runtime helpers', () => {
-    // The runtime `bf->find` / `find_index` / `find_last` / `find_last_index`
-    // call the predicate as a per-element coderef; the camelCase JS names map
-    // to the snake_case helpers (matching Xslate's Kolon-lambda lowering).
-    const cases: Array<[string, string]> = [
-      ['find', 'find'],
-      ['findIndex', 'find_index'],
-      ['findLast', 'find_last'],
-      ['findLastIndex', 'find_last_index'],
+  test('lowers .find / .findIndex / .findLast / .findLastIndex via the evaluator', () => {
+    // #2018 P2: the pure predicate `x => x === 'b'` serializes and lowers
+    // through the evaluator. find / findIndex share `bf->find_eval` /
+    // `bf->find_index_eval` with findLast / findLastIndex, distinguished by
+    // the `forward` flag (1 = forward, 0 = backward).
+    const cases: Array<[string, string, number]> = [
+      ['find', 'find_eval', 1],
+      ['findIndex', 'find_index_eval', 1],
+      ['findLast', 'find_eval', 0],
+      ['findLastIndex', 'find_index_eval', 0],
     ]
-    for (const [js, helper] of cases) {
+    for (const [js, helper, fwd] of cases) {
       const adapter = new MojoAdapter()
       const result = compileJSX(`function A({ items }: { items: string[] }) {
   return <div>{items.${js}(x => x === 'b')}</div>
@@ -995,11 +1008,45 @@ export { A }`, 'A.tsx', { adapter })
 export { A }`, 'A.tsx', { adapter })
       expect(result.errors?.filter(e => e.code === 'BF101') ?? []).toEqual([])
       const template = result.files.find(f => f.path.endsWith('.html.ep'))?.content ?? ''
-      expect(template).toContain(`bf->${helper}($items, sub { my $x = $_[0]; $x eq 'b' })`)
+      expect(template).toContain(`bf->${helper}($items,`)
+      expect(template).toContain(`'x', ${fwd}, {})`)
       expect(template).not.toContain(`$bf->${helper}`)
     }
   })
 
+  test('lowers .every / .some via the evaluator, with grep fallback for a method-call predicate', () => {
+    // #2018 P2: a pure predicate routes `.every` / `.some` through
+    // `bf->every_eval` / `bf->some_eval`; a method-call predicate the
+    // evaluator can't model (`serializeParsedExpr` → null) falls back to the
+    // inline `grep` form.
+    const evalCases: Array<[string, string]> = [
+      ['every', 'every_eval'],
+      ['some', 'some_eval'],
+    ]
+    for (const [js, helper] of evalCases) {
+      const adapter = new MojoAdapter()
+      const result = compileJSX(`function A({ items }: { items: { done: boolean }[] }) {
+  return <div>{items.${js}(x => x.done) ? 'y' : 'n'}</div>
+}
+export { A }`, 'A.tsx', { adapter })
+      expect(result.errors?.filter(e => e.code === 'BF101') ?? []).toEqual([])
+      const template = result.files.find(f => f.path.endsWith('.html.ep'))?.content ?? ''
+      expect(template).toContain(`bf->${helper}($items,`)
+      expect(template).toContain('"property":"done"')
+    }
+
+    // Fallback: a method-call predicate (`x => x.name.includes('a')`) is
+    // outside the evaluator surface, so `.every` keeps the inline grep form.
+    const adapter = new MojoAdapter()
+    const fb = compileJSX(`function A({ items }: { items: { name: string }[] }) {
+  return <div>{items.every(x => x.name.includes('a')) ? 'y' : 'n'}</div>
+}
+export { A }`, 'A.tsx', { adapter })
+    const fbTemplate = fb.files.find(f => f.path.endsWith('.html.ep'))?.content ?? ''
+    expect(fbTemplate).toContain('grep {')
+    expect(fbTemplate).not.toContain('every_eval')
+  })
+
   test('lowers .reverse().join(\' \') via bf->reverse + join (#1448 Tier A)', () => {
     // SSR templates render a snapshot, so `.reverse` and
     // `.toReversed` share a Mojo lowering — both return a new
@@ -1355,19 +1402,26 @@ describe('MojoAdapter - #1448 Tier A/B fixture-driven lowering pins', () => {
     // #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
-    // is one hash under `keys` (a single-key comparator → one element).
-    { fixture: arraySortFieldAscFixture,  expect: `bf->sort($items, { keys => [{ key_kind => 'field', key => 'price', compare_type => 'numeric', direction => 'asc' }] })` },
-    { fixture: arraySortFieldDescFixture, expect: `bf->sort($items, { keys => [{ key_kind => 'field', key => 'price', compare_type => 'numeric', direction => 'desc' }] })` },
-    { fixture: arraySortPrimitiveFixture, expect: `bf->sort($nums, { keys => [{ key_kind => 'self', compare_type => 'numeric', direction => 'asc' }] })` },
+    // #1448 Tier B — sort / toSorted. EXPR2 migration (#2018): both a
+    // STANDALONE `.sort(cmp)` value call AND the `.sort().map()` loop-hoist
+    // (#2018 P3) serialize the comparator body and emit `bf->sort_eval(...)`
+    // (JSON body + param names + captured env). `localeCompare` comparators
+    // fall back to the structured `bf->sort` — `serializeParsedExpr` refuses
+    // them. (Loop-hoist field cases pin only the helper + receiver; their
+    // comparator JSON is verified by the render conformance.)
+    { fixture: arraySortFieldAscFixture,  expect: `bf->sort_eval($items,` },
+    { fixture: arraySortFieldDescFixture, expect: `bf->sort_eval($items,` },
+    { fixture: arraySortPrimitiveFixture, expect: `bf->sort_eval($nums, '{"kind":"binary","op":"-","left":{"kind":"identifier","name":"a"},"right":{"kind":"identifier","name":"b"}}', 'a', 'b', {})` },
+    // localeCompare → outside the evaluator surface → legacy `bf->sort`.
     { fixture: arraySortLocaleFixture,    expect: `bf->sort($names, { keys => [{ key_kind => 'self', compare_type => 'string', direction => 'asc' }] })` },
-    // Multi-key (`||`-chain): one hash per comparison key, in order.
+    // Multi-key (`||`-chain): the second key is a `localeCompare`, so the
+    // whole comparator falls back to the structured `bf->sort` (one hash
+    // per comparison key, in order).
     { fixture: arraySortMultiKeyFixture,  expect: `bf->sort($items, { keys => [{ key_kind => 'field', key => 'price', compare_type => 'numeric', direction => 'asc' }, { key_kind => 'field', key => 'name', compare_type => 'string', direction => 'asc' }] })` },
-    // Relational-ternary comparator lowers to a single `auto` key.
-    { fixture: arraySortTernaryFixture,   expect: `bf->sort($items, { keys => [{ key_kind => 'field', key => 'rank', compare_type => 'auto', direction => 'asc' }] })` },
-    { fixture: arrayToSortedFixture,      expect: `bf->sort($nums, { keys => [{ key_kind => 'self', compare_type => 'numeric', direction => 'asc' }] })` },
+    // Relational-ternary comparator — a pure body, so the loop-hoist now
+    // serializes it through `bf->sort_eval` like the other field sorts.
+    { fixture: arraySortTernaryFixture,   expect: `bf->sort_eval($items,` },
+    { fixture: arrayToSortedFixture,      expect: `bf->sort_eval($nums, '{"kind":"binary","op":"-","left":{"kind":"identifier","name":"a"},"right":{"kind":"identifier","name":"b"}}', 'a', 'b', {})` },
     // #1448 Tier B — iteration shapes. These are loop-level patterns.
     // .entries() → for loop with both $i index var and $v value var
     { fixture: arrayEntriesFixture,       expect: '% my $v = $items->[$i];' },
@@ -1375,17 +1429,19 @@ 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' })` },
+    // #1448 Tier C — .reduce(fn, init) arithmetic fold. EXPR2 migration
+    // (#2018): the reducer body is serialized to ParsedExpr JSON and
+    // folded by `bf->reduce_eval(json, accName, itemName, init, direction,
+    // env)` — the runtime evaluator subsumes the old `+`/`*` catalogue.
+    // A numeric seed passes through bare (`0` / `1`); a concat seed as a
+    // single-quoted string (`''`). 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_eval($items, '{"kind":"binary","op":"+","left":{"kind":"identifier","name":"sum"},"right":{"kind":"member","object":{"kind":"identifier","name":"t"},"property":"duration"}}', 'sum', 't', 0, 'left', {})` },
+    { fixture: reduceSumSelfFixture,      expect: `bf->reduce_eval($nums, '{"kind":"binary","op":"+","left":{"kind":"identifier","name":"a"},"right":{"kind":"identifier","name":"b"}}', 'a', 'b', 0, 'left', {})` },
+    { fixture: reduceConcatFixture,       expect: `bf->reduce_eval($items, '{"kind":"binary","op":"+","left":{"kind":"identifier","name":"acc"},"right":{"kind":"member","object":{"kind":"identifier","name":"x"},"property":"label"}}', 'acc', 'x', '', 'left', {})` },
+    { fixture: reduceProductFixture,      expect: `bf->reduce_eval($items, '{"kind":"binary","op":"*","left":{"kind":"identifier","name":"acc"},"right":{"kind":"member","object":{"kind":"identifier","name":"x"},"property":"qty"}}', 'acc', 'x', 1, 'left', {})` },
+    { fixture: reduceRightConcatFixture,  expect: `bf->reduce_eval($items, '{"kind":"binary","op":"+","left":{"kind":"identifier","name":"acc"},"right":{"kind":"member","object":{"kind":"identifier","name":"x"},"property":"label"}}', 'acc', 'x', '', 'right', {})` },
   ]
 
   for (const { fixture, expect: expectedHelper } of cases) {
@@ -1444,20 +1500,26 @@ export { C }
     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', '')`)
+  // #2018 P3: `.flatMap(proj)` lowers through the evaluator — the projection
+  // body serializes to ParsedExpr JSON and `bf->flat_map_eval` flattens the
+  // results one level. (In Mojo the JSON rides in a single-quoted Perl string,
+  // so its double quotes are literal and assertable.)
+  test('.flatMap(i => i.field) emits bf->flat_map_eval with the field projection', () => {
+    const t = emitFlatMap('rows.flatMap(i => i.tags).join(" ")')
+    expect(t).toContain(`bf->flat_map_eval($rows,`)
+    expect(t).toContain(`"property":"tags"`)
   })
 
-  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('.flatMap(i => i) emits bf->flat_map_eval (self/identifier projection)', () => {
+    const t = emitFlatMap('rows.flatMap(i => i).join(" ")')
+    expect(t).toContain(`bf->flat_map_eval($rows,`)
+    expect(t).toContain(`"kind":"identifier","name":"i"`)
   })
 
-  test('tuple self + field leaves', () => {
-    expect(emitFlatMap('rows.flatMap(i => [i, i.a]).join(" ")')).toContain(`bf->flat_map_tuple($rows, ['self', ''], ['field', 'a'])`)
+  test('.flatMap(i => [i.a, i.b]) emits bf->flat_map_eval over an array-literal projection', () => {
+    const t = emitFlatMap('rows.flatMap(i => [i.a, i.b]).join(" ")')
+    expect(t).toContain(`bf->flat_map_eval($rows,`)
+    expect(t).toContain(`"kind":"array-literal"`)
   })
 
   test('field-projection flatMap as a loop base lowers (no BF101)', () => {
@@ -1470,7 +1532,7 @@ export function C() {
 }`, 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')`)
+    expect(template).toContain(`bf->flat_map_eval($items,`)
   })
 })
 
@@ -1537,9 +1599,11 @@ export function C() {
     // 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}' },
+    // #2018 P5: an array-literal projection with a literal element
+    // (`i => [i.name, "x"]`) now lowers through the runtime evaluator
+    // (`bf->flat_map_eval`) rather than refusing — the structured-tuple
+    // leaf restriction is gone. (Cross-adapter isomorphic with the Go
+    // adapter's `bf_flat_map_eval`.) Pinned positively below.
     // 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/__tests__/query-href.test.ts

@@ -0,0 +1,94 @@
+/**
+ * `queryHref(base, { … })` → `bf->query(...)` lowering for the Mojolicious
+ * adapter (#2042). Parity with the go-template `bf_query` lowering: the call +
+ * object literal are structured IR, so it lowers directly. The `bf->query`
+ * runtime helper (BarefootJS.pm) includes a pair iff its guard is truthy AND its
+ * value is a non-empty string, so a plain `key: v` passes guard `1` and a
+ * conditional `key: cond ? v : undefined` passes the lowered condition.
+ */
+import { describe, test, expect } from 'bun:test'
+import { compileJSX, type ComponentIR } from '@barefootjs/jsx'
+import { MojoAdapter } from '../adapter/mojo-adapter'
+
+function template(src: string): string {
+  const a = new MojoAdapter()
+  const r = compileJSX(src.trimStart(), 'T.tsx', { adapter: a, outputIR: true })
+  const ir = JSON.parse(r.files.find(f => f.type === 'ir')!.content) as ComponentIR
+  return a.generate(ir).template
+}
+
+describe('queryHref → bf->query (Mojo, #2042)', () => {
+  test('a plain value passes guard 1', () => {
+    const t = template(`
+'use client'
+import { queryHref } from '@barefootjs/client'
+export function P(props: { base: string; tag: string }) {
+  return <a href={queryHref(props.base, { tag: props.tag })}>x</a>
+}
+`)
+    expect(t).toContain("bf->query($base, 1, 'tag', $tag)")
+  })
+
+  test('a conditional include passes the lowered condition as the guard', () => {
+    const t = template(`
+'use client'
+import { queryHref } from '@barefootjs/client'
+export function P(props: { base: string; sort: string; tag: string }) {
+  return <a href={queryHref(props.base, { sort: props.sort !== 'date' ? props.sort : undefined, tag: props.tag })}>x</a>
+}
+`)
+    expect(t).toContain("bf->query($base, ($sort ne 'date'), 'sort', $sort, 1, 'tag', $tag)")
+  })
+
+  // A bare-value guard (`flag ? v : undefined`) is JS *string* truthiness — `'0'`
+  // is a truthy string in JS but false under Perl's `unless`. The lowering must
+  // normalise it to a non-empty-string test so SSR matches the client / go (where
+  // `lowerUrlGuard` emits `ne <value> ""`), not pass the bare value as the guard.
+  test('a bare-value guard is normalised to a non-empty-string test', () => {
+    const t = template(`
+'use client'
+import { queryHref } from '@barefootjs/client'
+export function P(props: { base: string; flag: string; val: string }) {
+  return <a href={queryHref(props.base, { q: props.flag ? props.val : undefined })}>x</a>
+}
+`)
+    expect(t).toContain("bf->query($base, ($flag ne ''), 'q', $val)")
+  })
+
+  // An array value (`{ tag: props.tags }`) lowers to the bare slice expression;
+  // the shared Perl `query` helper detects the arrayref at runtime and appends
+  // one pair per non-empty member (#2048). No adapter-side change beyond passing
+  // the value through.
+  test('an array value passes the slice expression for the helper to append', () => {
+    const t = template(`
+'use client'
+import { queryHref } from '@barefootjs/client'
+export function P(props: { base: string; tags: string[] }) {
+  return <a href={queryHref(props.base, { tag: props.tags })}>x</a>
+}
+`)
+    expect(t).toContain("bf->query($base, 1, 'tag', $tags)")
+  })
+
+  test('an aliased import is recognised', () => {
+    const t = template(`
+'use client'
+import { queryHref as qh } from '@barefootjs/client'
+export function P(props: { base: string; tag: string }) {
+  return <a href={qh(props.base, { tag: props.tag })}>x</a>
+}
+`)
+    expect(t).toContain("bf->query($base, 1, 'tag', $tag)")
+  })
+
+  test('a dynamic (non-literal) params object falls back (no bf->query)', () => {
+    const t = template(`
+'use client'
+import { queryHref } from '@barefootjs/client'
+export function P(props: { base: string; q: Record<string, string> }) {
+  return <a href={queryHref(props.base, props.q)}>x</a>
+}
+`)
+    expect(t).not.toContain('bf->query')
+  })
+})

package/src/adapter/analysis/component-tree.ts

@@ -0,0 +1,128 @@
+/**
+ * Component-tree analysis for the Mojolicious EP template adapter.
+ *
+ * Extracted from `mojo-adapter.ts` (domain-module refactor, issue #2018
+ * track D). Pure functions over the IR — they read no adapter instance
+ * state. `collectImportedLoopChildComponentErrors` returns its diagnostics
+ * instead of pushing onto the adapter's error list, so the adapter stays the
+ * sole owner of `errors`.
+ *
+ * SHARED CANDIDATE: `hasClientInteractivity` is byte-identical to the Xslate
+ * adapter's copy and adapter-agnostic; the BF103 loop-child check is the same
+ * structural walk in both, differing only in the Perl/Kolon diagnostic text —
+ * both are groundwork for a shared Perl-family codegen module (issue #2018
+ * track D).
+ */
+
+import type {
+  ComponentIR,
+  IRNode,
+  IRComponent,
+  IRElement,
+  IRFragment,
+  IRConditional,
+  IRLoop,
+  IRIfStatement,
+  IRProvider,
+  IRAsync,
+  CompilerError,
+} from '@barefootjs/jsx'
+
+/**
+ * Whether the component needs the client runtime — it owns reactive state
+ * (signals / effects / onMount) or the analyzer flagged it as needing init.
+ */
+export function hasClientInteractivity(ir: ComponentIR): boolean {
+  return (
+    ir.metadata.signals.length > 0 ||
+    ir.metadata.effects.length > 0 ||
+    ir.metadata.onMounts.length > 0 ||
+    (ir.metadata.clientAnalysis?.needsInit ?? false)
+  )
+}
+
+/**
+ * Build a `BF103` diagnostic for every component reference inside a loop body
+ * whose name is imported from a relative-path module. Mirror of the Go
+ * adapter's check — the Mojo adapter has the same cross-template-registration
+ * constraint at request time. Returns the diagnostics so the caller pushes
+ * them onto its own error list.
+ */
+export function collectImportedLoopChildComponentErrors(
+  ir: ComponentIR,
+  componentName: string,
+): CompilerError[] {
+  const errors: CompilerError[] = []
+  // Collect every name imported from a relative-path module (no
+  // case filter — `IRComponent` nodes only exist for PascalCase JSX
+  // usages, so a lowercase utility import in the set can't match
+  // anyway, and any heuristic on the import name itself would be
+  // strictly less robust than the structural IR check below).
+  const relativeImports = new Set<string>()
+  for (const imp of ir.metadata.templateImports ?? ir.metadata.imports ?? []) {
+    if (!imp.source.startsWith('./') && !imp.source.startsWith('../')) continue
+    if (imp.isTypeOnly) continue
+    for (const spec of imp.specifiers) {
+      relativeImports.add(spec.alias ?? spec.name)
+    }
+  }
+  if (relativeImports.size === 0) return errors
+
+  const loc = { file: componentName + '.tsx', start: { line: 1, column: 0 }, end: { line: 1, column: 0 } }
+  const visit = (node: IRNode, inLoop: boolean): void => {
+    switch (node.type) {
+      case 'component': {
+        const comp = node as IRComponent
+        if (inLoop && relativeImports.has(comp.name)) {
+          errors.push({
+            code: 'BF103',
+            severity: 'error',
+            message: `Component <${comp.name}> is imported from a sibling module and used inside a loop. The Mojo adapter emits a cross-template call; the child template must be registered alongside the parent at render time.`,
+            loc: comp.loc ?? loc,
+            suggestion: {
+              message:
+                `Options:\n` +
+                `  1. Compile '${comp.name}' (its source file) with the same adapter and register the resulting Mojo template alongside the parent at render time.\n` +
+                `  2. Inline <${comp.name}> directly inside the loop body so no cross-file template lookup is needed.\n` +
+                `  3. Mark the loop position as @client-only so the template is materialised on the client instead of at SSR time.`,
+            },
+          })
+        }
+        for (const child of comp.children) visit(child, inLoop)
+        break
+      }
+      case 'element':
+        for (const child of (node as IRElement).children) visit(child, inLoop)
+        break
+      case 'fragment':
+        for (const child of (node as IRFragment).children) visit(child, inLoop)
+        break
+      case 'conditional': {
+        const cond = node as IRConditional
+        visit(cond.whenTrue, inLoop)
+        if (cond.whenFalse) visit(cond.whenFalse, inLoop)
+        break
+      }
+      case 'loop':
+        for (const child of (node as IRLoop).children) visit(child, true)
+        break
+      case 'if-statement': {
+        const stmt = node as IRIfStatement
+        visit(stmt.consequent, inLoop)
+        if (stmt.alternate) visit(stmt.alternate, inLoop)
+        break
+      }
+      case 'provider':
+        for (const child of (node as IRProvider).children) visit(child, inLoop)
+        break
+      case 'async': {
+        const a = node as IRAsync
+        visit(a.fallback, inLoop)
+        for (const child of a.children) visit(child, inLoop)
+        break
+      }
+    }
+  }
+  visit(ir.root, false)
+  return errors
+}