@barefootjs/mojolicious 0.17.0 → 0.18.0

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

@@ -6,12 +6,10 @@
 
 import { describe, test, expect } from 'bun:test'
 import { MojoAdapter } from '../adapter/mojo-adapter'
-import {
-  runAdapterConformanceTests,
-  TemplatePrimitiveCaseId,
-} from '@barefootjs/adapter-tests'
+import { runAdapterConformanceTests } from '@barefootjs/adapter-tests'
 import { renderMojoComponent, PerlNotAvailableError } from '../test-render'
 import { compileJSX, type ComponentIR } from '@barefootjs/jsx'
+import { conformancePins } from '../conformance-pins'
 
 runAdapterConformanceTests({
   name: 'mojo',
@@ -25,134 +23,27 @@ runAdapterConformanceTests({
   // body children (TableCell) now receive `_bf_slot` for deterministic
   // parent-scope-derived IDs matching Hono.
   // Per-fixture build-time contracts for shapes the Mojo adapter
-  // intentionally refuses to lower. Owned by this adapter test file
-  // (not by the shared fixtures) so adding a new adapter doesn't
-  // require touching any cross-adapter file.
-  expectedDiagnostics: {
-    // Sibling-imported child component in a loop body: Mojo emits
-    // a cross-template call that needs separate registration. BF103
-    // makes the requirement loud. (The barefoot CLI passes
-    // `siblingTemplatesRegistered: true` so CLI builds suppress it.)
-    'static-array-children': [{ code: 'BF103', severity: 'error' }],
-    // TodoApp / TodoAppSSR import `TodoItem` from a sibling file and
-    // call it inside a keyed `.map`. Same BF103 surface as the
-    // synthetic `static-array-children` above — pinned at adapter
-    // level so the shared-component corpus stays adapter-neutral.
-    'todo-app': [{ code: 'BF103', severity: 'error' }],
-    'todo-app-ssr': [{ code: 'BF103', severity: 'error' }],
-    // Array-destructure loop param (`([k, v]) => ...`) lowers to
-    // invalid Perl (`% my $[k, v] = $entries->[$_i];`).
-    'static-array-from-props': [{ code: 'BF104', severity: 'error' }],
-    // Both BF103 (imported child) and BF104 (destructure) fire.
-    'static-array-from-props-with-component': [
-      { code: 'BF103', severity: 'error' },
-      { code: 'BF104', severity: 'error' },
-    ],
-    // #1310: rest destructure in .map() callback. The object-rest shape read
-    // via member access (`rest-destructure-object-in-map`) now lowers — each
-    // binding becomes a Perl `my` local off the per-item var (`$rest` aliases
-    // the item so `$rest->{flag}` resolves). The other three stay refused:
-    // rest SPREAD (`{...rest}`) needs a residual hash, and array-index /
-    // nested paths can't unpack into scalar `my`s.
-    'rest-destructure-object-spread-in-map': [{ code: 'BF104', severity: 'error' }],
-    'rest-destructure-array-in-map': [{ code: 'BF104', severity: 'error' }],
-    'rest-destructure-nested-in-map': [{ code: 'BF104', severity: 'error' }],
-    // `style-3-signals` / `style-object-dynamic` no longer pinned — a
-    // `style={{ … }}` object literal now lowers to a CSS string with dynamic
-    // values interpolated (`background-color:<%= $color %>;padding:8px`) via
-    // `tryLowerStyleObject` (#1322).
-    // #1244 stress catalog #12 (#1323): tagged-template-literal call
-    // (`cn\`base \${tone()}\``) — same family as #1322 above and refused
-    // via the same gate.
-    'tagged-template-classname': [{ code: 'BF101', severity: 'error' }],
-    // #1467 demo-corpus context providers (`radio-group`, `accordion`,
-    // `dialog`, `popover`, `select`, `dropdown-menu`, `combobox`,
-    // `command`) are no longer pinned — an object-literal provider value
-    // (`{ open: () => props.open ?? false, onOpenChange: (v) => {…} }`)
-    // lowers to a Perl hashref via `parseProviderObjectLiteral` (#1897):
-    // getter members snapshot their body's SSR value, handler /
-    // function-shaped members lower to `undef`. The command demo's
-    // `ref={(el) => {…}}` function prop on an imported component is
-    // skipped at SSR like `on*` handlers.
-    //
-    // #1467 Phase 2e: `data-table` is no longer pinned here either — it
-    // compiles clean (`selected()[index]` → `index-access`,
-    // `.toFixed(2)` → `bf->to_fixed`, `/* @client */` memo SSR-folded)
-    // and renders to Hono parity on real Mojolicious. The keyed-loop
-    // scope-ID divergence (#1896) was fixed by the body-children
-    // `inLoop` reset (loop-item children get `_bf_slot`); data-table is
-    // off `skipJsx` entirely and only kept in `skipMarkerConformance`
-    // below for the shared `/* @client */` keyed-map slot-id elision
-    // contract (same as `todo-app`), not a render or BF101 gap.
-    // #1443: `[a, b].filter(Boolean).join(' ')` (the registry Slot's
-    // shape) now lowers to `join(' ', @{[grep { $_ } @{[$a, $b]}]})`.
-    // No BF101 expected — pinned positively via the
-    // `branch-local-filter-join` template-output test below.
-    //
-    // #1448 Tier A — JS Array / String methods that the Mojo adapter
-    // hasn't lowered yet. Each row drops once the corresponding
-    // method PR lands. Hono / CSR pass these out of the box (they
-    // evaluate JS at runtime) so the pin only applies here.
-    //
-    // `array-includes` / `string-includes` no longer pinned — both
-    // shapes lower via the shared `array-method` IR + `bf->includes`
-    // runtime dispatch (#1448 Tier A first PR).
-    // `array-indexOf` / `array-lastIndexOf` no longer pinned —
-    // value-equality `bf->index_of` / `bf->last_index_of` helpers
-    // handle the shape (#1448 Tier A second PR).
-    // `array-at` no longer pinned — `bf->at` (Mojo) / `bf_at` (Go)
-    // handle the negative-index lookup (#1448 Tier A third PR).
-    // `array-concat` no longer pinned — `bf->concat` (Mojo) /
-    // `bf_concat` (Go) merge two arrays into a new array
-    // (#1448 Tier A fourth PR).
-    // `array-slice` no longer pinned — `bf->slice` (Mojo) /
-    // `bf_slice` (Go) carve out a sub-range with JS-compat
-    // negative-index / out-of-bounds clamping (#1448 Tier A
-    // fifth PR).
-    // `array-reverse` / `array-toReversed` no longer pinned —
-    // both share the `bf->reverse` / `bf_reverse` helper since
-    // SSR templates render a snapshot and the JS mutate-vs-new
-    // distinction has no template-level meaning (#1448 Tier A
-    // sixth PR).
-    // `string-toLowerCase` / `string-toUpperCase` no longer pinned —
-    // Perl's native `lc` / `uc` (Mojo) and pre-existing
-    // `bf_lower` / `bf_upper` (Go) handle the JS method names
-    // (#1448 Tier A seventh + eighth PRs).
-    // `string-trim` no longer pinned — pre-existing `bf_trim`
-    // (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 `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'`).
-  },
-  // `JSON_STRINGIFY_VIA_CONST` and `MATH_FLOOR_VIA_CONST` now pass
-  // via `MojoAdapter.templatePrimitives` (#1189). The two remaining
-  // cases stay skipped because the V1 registry is identifier-path-
-  // only and explicit:
-  //   - `USER_IMPORT_VIA_CONST` — a bespoke user import isn't in
-  //     the registry and can't be rendered server-side without
-  //     user-supplied helper mappings.
-  //   - `NO_DOUBLE_REWRITE_OF_PROPS_OBJECT` — uses `customSerialize`
-  //     too, same reason.
-  // Adding new entries to `templatePrimitives` should narrow this
-  // skip set; see `MOJO_TEMPLATE_PRIMITIVES` in `mojo-adapter.ts`
-  // for the full V1 surface.
-  skipTemplatePrimitives: new Set([
-    TemplatePrimitiveCaseId.USER_IMPORT_VIA_CONST,
-    TemplatePrimitiveCaseId.NO_DOUBLE_REWRITE_OF_PROPS_OBJECT,
-  ]),
-  // Mojo `renderLoop` does not yet emit the `bf->comment("loop:<id>")`
-  // boundary markers when the loop is `@client` (Hono and Go both do).
-  // The client runtime relies on these markers to locate the insertion
-  // anchor when hydrating the array; without them, mapArray() resolves
-  // anchor = null and appends after sibling markers (#872 parity).
-  // Tracked as a follow-up; remove from this set when Mojo emits the
-  // boundary pair for clientOnly loops too.
+  // intentionally refuses to lower. Lives in `../conformance-pins` (not
+  // by the shared fixtures) so adding a new adapter doesn't require
+  // touching any cross-adapter file.
+  expectedDiagnostics: conformancePins,
+  // `JSON_STRINGIFY_VIA_CONST` and `MATH_FLOOR_VIA_CONST` pass via
+  // `MojoAdapter.templatePrimitives` (#1189) — the identifier-path
+  // registry for well-known JS builtins. `USER_IMPORT_VIA_CONST` and
+  // `NO_DOUBLE_REWRITE_OF_PROPS_OBJECT` now ALSO pass (#2069): a bespoke
+  // user import can never be added to the string-keyed registry, but the
+  // shared `RelocateEnv.loweringMatchers` acceptance path recognises it
+  // via a `LoweringPlugin` the case setup registers around the compile
+  // (see `packages/adapter-tests/src/cases/template-primitives.ts`) — the
+  // same seam a real userland plugin author would use. No skips left, so
+  // `skipTemplatePrimitives` is omitted entirely (defaults to "skip
+  // nothing").
+  // `client-only` / `client-only-loop-with-sibling-cond` /
+  // `filter-nested-callback-predicate-client` are no longer skipped —
+  // `renderLoop` now emits the `bf->comment("loop:<id>")` boundary pair
+  // for clientOnly loops (Hono / Go parity), so mapArray() can locate
+  // its insertion anchor at hydration time (#872 / #1087).
   skipMarkerConformance: new Set([
-    'client-only',
-    'client-only-loop-with-sibling-cond',
     // Same as Hono: `/* @client */` markers on TodoApp's keyed `.map`
     // intentionally elide a slot id from the SSR template that the IR
     // still declares (s6). See hono-adapter.test for the contract.
@@ -792,6 +683,31 @@ export function C() {
     expect(template).toContain('scalar(@{[grep { $_->{active} } @{$t->{tags}}]})')
   })
 
+  test('lowers nested .some(...) in filter predicate to an inline grep — no BF101 (#2038)', () => {
+    // The evaluator refuses the nested arrow (`serializeParsedExpr` → null),
+    // but the Perl filter emitter has a FAITHFUL form for nested
+    // filter / every / some: a real inline `grep` closing over the outer
+    // loop var. Pin the emitted EP shape positively so the #2038 loudness
+    // fix (which targets the degrade-only arms: nested `find*`,
+    // sort / reduce / flatMap — see the `filter-nested-find-predicate`
+    // expectedDiagnostics entry) never over-reaches into this supported
+    // shape. The rendered-HTML side of this contract lives in the shared
+    // `filter-nested-callback-predicate` fixture (Hono-parity render).
+    const adapter = new MojoAdapter()
+    const result = compileJSX(`'use client'
+import { createSignal } from '@barefootjs/client'
+type Item = { id: number }
+export function Picker() {
+  const [items] = createSignal<Item[]>([])
+  const [picked] = createSignal<Item[]>([])
+  return <ul>{items().filter(t => !picked().some(p => p.id === t.id)).map(t => <li key={t.id}>{t.id}</li>)}</ul>
+}`, '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')
+    expect(template).toContain('@{$picked}')
+  })
+
   test('lowers .filter(function (x) { return x.done }).map(...) — function-keyword filter (#1443)', () => {
     // Function expressions with a single `return <expr>` body normalise
     // to the arrow-fn IR shape at parse time, so the higher-order
@@ -1035,11 +951,26 @@ export { A }`, 'A.tsx', { adapter })
       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.
+    // #2075: `.includes(x)` is now in the evaluator surface (`array-method`
+    // gate, shared with the Perl `Evaluator.pm` runtime), so a method-call
+    // predicate built from it ALSO routes through `every_eval` rather than
+    // falling back — it's no longer the "unsupported method call" example.
+    const includesAdapter = new MojoAdapter()
+    const includesResult = compileJSX(`function A({ items }: { items: { name: string }[] }) {
+  return <div>{items.every(x => x.name.includes('a')) ? 'y' : 'n'}</div>
+}
+export { A }`, 'A.tsx', { adapter: includesAdapter })
+    const includesTemplate = includesResult.files.find(f => f.path.endsWith('.html.ep'))?.content ?? ''
+    expect(includesTemplate).toContain('bf->every_eval($items,')
+    expect(includesTemplate).toContain('"method":"includes"')
+    expect(includesTemplate).not.toContain('grep {')
+
+    // Fallback: a method-call predicate the evaluator still can't model
+    // (`.toUpperCase()` is outside the `array-method` gate — only `includes`
+    // is recognized there) 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>
+  return <div>{items.every(x => x.name.toUpperCase() === 'A') ? 'y' : 'n'}</div>
 }
 export { A }`, 'A.tsx', { adapter })
     const fbTemplate = fb.files.find(f => f.path.endsWith('.html.ep'))?.content ?? ''
@@ -1488,6 +1419,110 @@ export { C }
   })
 })
 
+describe('MojoAdapter - #2075 searchParams()-derived memo seeding', () => {
+  // A memo derived from the createSearchParams() env signal must seed
+  // in-template from the canonical per-request `$searchParams` reader —
+  // including under a local alias (`const [sp] = …`), which the expression
+  // lowering canonicalises.
+  test('seeds an aliased scalar derived memo from the canonical reader', () => {
+    const { template } = compileAndGenerate(`
+'use client'
+import { createMemo, createSearchParams } from '@barefootjs/client'
+export function SortStatus() {
+  const [sp] = createSearchParams()
+  const sort = createMemo(() => sp().get('sort') ?? 'date')
+  return <p>sort: {sort()}</p>
+}
+`)
+    expect(template).toContain("% my $sort = ($searchParams->get('sort') // 'date');")
+  })
+
+  // A list-filter memo chained off the derived memo seeds too: the inline
+  // grep's `$_` topic and the callback param are lowering-internal bindings,
+  // not out-of-scope template vars (the pre-#2075 availability check
+  // rejected them and the list rendered empty at SSR).
+  test('seeds a filter memo chained off the derived memo', () => {
+    const { template } = compileAndGenerate(`
+'use client'
+import { createMemo, createSearchParams } from '@barefootjs/client'
+export function TaggedList(props: { items: { title: string; tags: string[] }[] }) {
+  const [searchParams] = createSearchParams()
+  const tag = createMemo(() => searchParams().get('tag') ?? '')
+  const visible = createMemo(() => props.items.filter((p) => !tag() || p.tags.includes(tag())))
+  return <ul>{visible().map((p) => <li key={p.title}>{p.title}</li>)}</ul>
+}
+`)
+    expect(template).toContain("% my $tag = ($searchParams->get('tag') // '');")
+    expect(template).toMatch(/% my \$visible = \[grep/)
+  })
+
+  // The seed-scope guard used to scan the LOWERED
+  // Perl string, allowing every arrow-callback param tree-wide. That let an
+  // outer, unbound `p` (shadowed only inside the callback) slip past the
+  // guard as if it were the callback's own bound `$p` — emitting a bogus
+  // seed line that would crash Perl strict mode. The guard now walks the
+  // parsed SOURCE tree with proper lexical scoping (`freeIdentifiers`), so
+  // this shape seeds nothing and falls back to the null/ssr-defaults path.
+  test('an outer unbound `p` shadowed only inside the callback does not seed', () => {
+    const { template } = compileAndGenerate(`
+'use client'
+import { createMemo } from '@barefootjs/client'
+export function C(props: { items: { ok: boolean }[] }) {
+  const visible = createMemo(() => props.items.filter((p) => p.ok) && p)
+  return <div>{String(visible())}</div>
+}
+`)
+    expect(template).not.toContain('my $visible')
+  })
+
+  // An out-of-scope bare `_` reference (not the `grep` topic var of an
+  // in-scope higher-order lowering) must not seed either — the old
+  // unconditional `allowed.add('_')` masked this.
+  test('an out-of-scope bare `_` reference does not seed', () => {
+    const { template } = compileAndGenerate(`
+'use client'
+import { createMemo } from '@barefootjs/client'
+export function C(props: { count: number }) {
+  const doubled = createMemo(() => props.count * 2 + _)
+  return <div>{doubled()}</div>
+}
+`)
+    expect(template).not.toContain('my $doubled')
+  })
+})
+
+describe('MojoAdapter - #2073 value-producing .map(cb)', () => {
+  function emitMap(expr: string): string {
+    const a = new MojoAdapter()
+    const ir = compileToIR(`
+function C({ tags, users }: { tags: string[]; users: { name: string }[] }) {
+  return <div>{${expr}}</div>
+}
+export { C }
+`, a)
+    return a.generate(ir).template ?? ''
+  }
+
+  // The blog-showcase shape (#1938/#1939): a value-returning `.map` (string
+  // projection, not JSX) lowers through the evaluator — `bf->map_eval`
+  // projects each element (no flatten) and composes through `.join`.
+  test('.map(t => `#${t}`).join(" ") emits bf->map_eval composed into join', () => {
+    const t = emitMap("tags.map(t => `#${t}`).join(' ')")
+    expect(t).toContain(`join(' ', @{bf->map_eval($tags,`)
+    expect(t).toContain(`"kind":"template-literal"`)
+  })
+
+  test('.map(u => u.name) emits bf->map_eval with the field projection', () => {
+    const t = emitMap("users.map(u => u.name).join(', ')")
+    expect(t).toContain(`bf->map_eval($users,`)
+    expect(t).toContain(`"property":"name"`)
+  })
+
+  // The function-reference `.map(format)` BF101 refusal is now covered
+  // cross-adapter by the `array-map-function-reference` shared fixture's
+  // `expectedDiagnostics` entry above.
+})
+
 describe('MojoAdapter - #1448 Tier C .flatMap(field projection)', () => {
   function emitFlatMap(expr: string): string {
     const a = new MojoAdapter()
@@ -1706,7 +1741,6 @@ export { C }
   // contract here is: no errors + the comparator never lowers + no
   // rendered `<li>` survives.
   const unsupportedSort: Array<[string, string]> = [
-    ['function-reference comparator', `items().toSorted(myCmp).map(x => <li key={x.name}>{x.name}</li>)`],
     ['localeCompare locale/options arg', `items().toSorted((a, b) => a.name.localeCompare(b.name, "ja", { numeric: true })).map(x => <li key={x.name}>{x.name}</li>)`],
   ]
   for (const [label, chain] of unsupportedSort) {
@@ -1730,6 +1764,17 @@ export function C() {
     })
   }
 
+  // #2090: a function-reference comparator (`.toSorted(myCmp)`, `myCmp` a
+  // same-file const arrow) now resolves through the analyzer's scope
+  // machinery and compiles — no BF021, and the sort lowers exactly like an
+  // inline comparator (a `bf->sort` / `bf->sort_eval` call in the template).
+  test('sort follow-up (function-reference comparator): resolves and compiles without BF021', () => {
+    const chain = `items().toSorted(myCmp).map(x => <li key={x.name}>{x.name}</li>)`
+    const result = emitLoop(chain, false)
+    expect(result.errors).toEqual([])
+    expect(result.template).toMatch(/bf->sort/)
+  })
+
   // End-to-end proof via perl + Mojolicious: the `@client` form renders
   // a `<!--bf-client:sN-->` placeholder. The bare form is now caught at
   // build with BF101 and degrades to an empty, render-safe slot (no

package/src/__tests__/multi-component-registry.test.ts

@@ -0,0 +1,215 @@
+// Multi-component registry modules on the Mojo plugin path (#2132).
+//
+// A registry module that exports several components from one file —
+// `ui/toast/index.tsx` exporting ToastProvider / Toast / ToastTitle — compiles
+// to one EP template PER component, and every compiled parent invokes each one
+// under its snake_cased name (`bf->render_child('toast_provider')`). The
+// manifest entry used to carry only the module's FIRST template, so
+// `register_components_from_manifest` registered nothing for the
+// sub-components and every page using Toast / Dialog / Tabs 500'd with
+// "No renderer registered for child component 'toast_provider'".
+//
+// This is the in-repo equivalent of the issue's repro: `bf add toast` →
+// render a <Toast>-using component on mojo → expect 200 with toast markup.
+// It boots a real Mojolicious app with the production plugin against
+// compiler-produced templates plus a manifest in the shape `bf build` now
+// emits (per-component rows under `components` — pinned on the emitter side
+// by packages/cli/src/__tests__/build-manifest-components.test.ts).
+//
+// Runs only when `perl` with Mojolicious is installed (same skip policy as
+// stock-route.test.ts, which this file mirrors).
+
+import { describe, test, expect, beforeAll } from 'bun:test'
+import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import { compileJSX } from '@barefootjs/jsx'
+import { MojoAdapter } from '../adapter/mojo-adapter'
+
+const MOJO_LIB_DIR = path.resolve(import.meta.dir, '../../lib')
+const PERL_CORE_LIB_DIR = path.resolve(import.meta.dir, '../../../adapter-perl/lib')
+
+function perlWithMojoAvailable(): boolean {
+  try {
+    const proc = Bun.spawnSync(['perl', '-MMojolicious', '-MTest::Mojo', '-e1'], {
+      env: process.env,
+    })
+    return proc.exitCode === 0
+  } catch {
+    return false
+  }
+}
+
+const PERL_AVAILABLE = perlWithMojoAvailable()
+
+// The registry-toast shape: one module, several exported components, one of
+// them ("Toast") snake_casing to the module's directory name — the collision
+// that used to render the WRONG template even when the name resolved.
+const TOAST_TSX = `'use client'
+
+interface ToastProviderProps {
+  children?: any
+}
+
+export function ToastProvider({ children }: ToastProviderProps) {
+  return <div data-slot="toast-provider">{children}</div>
+}
+
+interface ToastProps {
+  open?: boolean
+  children?: any
+}
+
+export function Toast({ open = false, children }: ToastProps) {
+  return (
+    <div data-slot="toast" data-state={open ? 'open' : 'closed'}>
+      {children}
+    </div>
+  )
+}
+
+export function ToastTitle({ children }: { children?: any }) {
+  return <div data-slot="toast-title">{children}</div>
+}
+`
+
+// The issue's ToastProbe: a page component driving the module's
+// sub-components, with a signal feeding Toast's `open` prop.
+const PROBE_TSX = `'use client'
+import { createSignal } from '@barefootjs/client'
+import { ToastProvider, Toast, ToastTitle } from '@/components/ui/toast'
+
+export function ToastProbe() {
+  const [open, setOpen] = createSignal(true)
+  return (
+    <ToastProvider>
+      <Toast open={open()}>
+        <ToastTitle>hi</ToastTitle>
+      </Toast>
+    </ToastProvider>
+  )
+}
+`
+
+const APP_PL = `#!/usr/bin/env perl
+use Mojolicious::Lite -signatures;
+
+plugin 'BarefootJS';
+
+app->renderer->paths->[0] = app->home->child('dist/templates');
+
+get '/toast-probe' => sub ($c) {
+    $c->render(template => 'ToastProbe', layout => 'default');
+};
+
+app->start;
+
+__DATA__
+
+@@ layouts/default.html.ep
+<!DOCTYPE html>
+<html><body>
+<main><%== content %></main>
+%== $c->bf->scripts
+</body></html>
+`
+
+const SMOKE_PL = `use Mojo::Base -strict;
+use Test::More;
+use Test::Mojo;
+use Mojo::File qw(curfile);
+
+my $t = Test::Mojo->new(curfile->dirname->child('app.pl'));
+
+# The issue's regression bar: 200 with toast markup (was a 500 with
+# "No renderer registered for child component 'toast_provider'").
+$t->get_ok('/toast-probe')->status_is(200)
+  ->element_exists('[data-slot="toast-provider"]', 'provider rendered')
+  ->element_exists('[data-slot="toast"]',          'toast rendered')
+  ->element_exists('[data-slot="toast-title"]',    'title rendered')
+  ->text_like('[data-slot="toast-title"]', qr/hi/, 'children reached the title')
+  ->element_exists('[data-slot="toast"][data-state="open"]',
+      'parent signal reached the sub-component prop (not Toast\\'s own open=false default)');
+
+done_testing;
+`
+
+describe.skipIf(!PERL_AVAILABLE)('Mojo multi-component registry modules (#2132)', () => {
+  let appDir: string
+
+  beforeAll(() => {
+    appDir = mkdtempSync(path.join(tmpdir(), 'bf-mojo-multi-component-'))
+    mkdirSync(path.join(appDir, 'dist/templates/ui/toast'), { recursive: true })
+
+    const adapter = new MojoAdapter()
+
+    // Compile the multi-component module: one template + ssr-defaults pair
+    // per exported component, each stamped with its componentName.
+    const toastResult = compileJSX(TOAST_TSX, 'components/ui/toast/index.tsx', { adapter })
+    const toastErrors = toastResult.errors.filter(e => e.severity === 'error')
+    if (toastErrors.length > 0) {
+      throw new Error(`toast module compile failed:\n${toastErrors.map(e => e.message).join('\n')}`)
+    }
+    const componentRows: Record<string, { markedTemplate: string; ssrDefaults?: unknown }> = {}
+    const toastTemplates = toastResult.files.filter(f => f.type === 'markedTemplate')
+    for (const tpl of toastTemplates) {
+      const fileName = path.basename(tpl.path)
+      writeFileSync(path.join(appDir, 'dist/templates/ui/toast', fileName), tpl.content)
+      const defaults = toastResult.files.find(
+        f => f.type === 'ssrDefaults' && f.componentName === tpl.componentName,
+      )
+      componentRows[tpl.componentName!] = {
+        markedTemplate: `templates/ui/toast/${fileName}`,
+        ...(defaults ? { ssrDefaults: JSON.parse(defaults.content) } : {}),
+      }
+    }
+    expect(Object.keys(componentRows).sort()).toEqual(['Toast', 'ToastProvider', 'ToastTitle'])
+
+    // Compile the probe page.
+    const probeResult = compileJSX(PROBE_TSX, 'components/ToastProbe.tsx', { adapter })
+    const probeErrors = probeResult.errors.filter(e => e.severity === 'error')
+    if (probeErrors.length > 0) {
+      throw new Error(`probe compile failed:\n${probeErrors.map(e => e.message).join('\n')}`)
+    }
+    const probeTemplate = probeResult.files.find(f => f.type === 'markedTemplate')
+    const probeDefaults = probeResult.files.find(f => f.type === 'ssrDefaults')
+    if (!probeTemplate) throw new Error('probe compile produced no template')
+    writeFileSync(path.join(appDir, 'dist/templates/ToastProbe.html.ep'), probeTemplate.content)
+
+    // Same entry shape `bf build` writes to dist/templates/manifest.json
+    // (see build-manifest-components.test.ts for the emitter pin).
+    writeFileSync(
+      path.join(appDir, 'dist/templates/manifest.json'),
+      JSON.stringify({
+        ToastProbe: {
+          markedTemplate: 'templates/ToastProbe.html.ep',
+          ...(probeDefaults ? { ssrDefaults: JSON.parse(probeDefaults.content) } : {}),
+        },
+        'ui/toast/index': {
+          markedTemplate: componentRows[toastTemplates[0].componentName!].markedTemplate,
+          components: componentRows,
+        },
+      }),
+    )
+    writeFileSync(path.join(appDir, 'app.pl'), APP_PL)
+    writeFileSync(path.join(appDir, 'smoke.pl'), SMOKE_PL)
+  })
+
+  test('a <Toast>-using page renders 200 with toast markup', async () => {
+    const perl5lib = [MOJO_LIB_DIR, PERL_CORE_LIB_DIR, process.env.PERL5LIB]
+      .filter(Boolean)
+      .join(':')
+    const proc = Bun.spawn(['perl', 'smoke.pl'], {
+      cwd: appDir,
+      env: { ...process.env, PERL5LIB: perl5lib },
+      stdout: 'pipe',
+      stderr: 'pipe',
+    })
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ])
+    expect(exitCode, `TAP output:\n${stdout}\n${stderr}`).toBe(0)
+  })
+})