@barefootjs/mojolicious 0.17.1 → 0.18.1

package/lib/Mojolicious/Plugin/BarefootJS.pm

@@ -1,5 +1,5 @@
 package Mojolicious::Plugin::BarefootJS;
-our $VERSION = "0.17.0";
+our $VERSION = "0.18.0";
 use Mojo::Base 'Mojolicious::Plugin', -signatures;
 
 use Mojo::File qw(path);
@@ -31,28 +31,64 @@ sub register ($self, $app, $config = {}) {
         $c->stash->{'bf.instance'} //= BarefootJS->new($c, $config);
     });
 
-    my $manifest = _load_manifest($app, $config);
-    return unless $manifest;
-
-    # Cache the set of UI-registry slot keys so we can answer
-    # "is this template name a child or a top-level page?" with a
-    # single hash lookup at render time. Top-level entries are
-    # everything that isn't `__barefoot__` and doesn't match
-    # `ui/<name>/index` — the same partition `register_components_from_manifest`
-    # applies internally.
-    my %is_child_entry;
-    for my $entry_name (keys %$manifest) {
-        next if $entry_name eq '__barefoot__';
-        next unless $entry_name =~ m{^ui/[^/]+/index$};
-        $is_child_entry{$entry_name} = 1;
-    }
+    return if exists $config->{manifest_path} && !defined $config->{manifest_path};
+    my $manifest_path = path(
+        $config->{manifest_path} // $app->home->child('dist/templates/manifest.json'));
+
+    # Manifest resolution is lazy, re-checked per render (#2126). The
+    # scaffold's dev script starts `bf build --watch` and the web server
+    # concurrently, so the app routinely boots before the first build has
+    # written `manifest.json`. Loading once at register time turned that
+    # startup race into a permanent failure: auto-init stayed disabled for
+    # the server's lifetime and every top-level render died under strict
+    # (`Global symbol "$initial" requires explicit package name`). The
+    # cache is keyed on the file's (mtime, size), so the steady-state cost
+    # is one stat() per render — and `bf build --watch` rebuilds (new
+    # ssrDefaults, `bf add`ed components) are picked up without a restart.
+    my ($cached_sig, $manifest, $is_child_entry);
+    my $load_manifest = sub {
+        my ($size, $mtime) = (stat "$manifest_path")[7, 9];
+        unless (defined $mtime) {
+            # Missing (or unreadable) — drop the cache so the manifest is
+            # re-read as soon as the first build writes it.
+            ($cached_sig, $manifest, $is_child_entry) = (undef, undef, undef);
+            return undef;
+        }
+        my $sig = "$mtime/$size";
+        return $manifest if defined $cached_sig && $cached_sig eq $sig;
+        # Cache parse failures under the same signature so a broken file
+        # warns once, not on every render, and retries when it changes.
+        $cached_sig = $sig;
+        ($manifest, $is_child_entry) = (undef, undef);
+        my $m = eval { decode_json($manifest_path->slurp) };
+        if ($@ || ref($m) ne 'HASH') {
+            $app->log->warn("BarefootJS: cannot parse manifest at $manifest_path: $@") if $@;
+            return undef;
+        }
+        $manifest = $m;
+
+        # Cache the set of UI-registry slot keys so we can answer
+        # "is this template name a child or a top-level page?" with a
+        # single hash lookup at render time. Top-level entries are
+        # everything that isn't `__barefoot__` and doesn't match
+        # `ui/<name>/index` — the same partition `register_components_from_manifest`
+        # applies internally.
+        $is_child_entry = {};
+        for my $entry_name (keys %$manifest) {
+            next if $entry_name eq '__barefoot__';
+            next unless $entry_name =~ m{^ui/[^/]+/index$};
+            $is_child_entry->{$entry_name} = 1;
+        }
+        return $manifest;
+    };
 
     $app->hook(before_render => sub ($c, $args) {
         my $template = $args->{template};
         return unless defined $template && length $template;
-        my $entry = $manifest->{$template};
+        my $m = $load_manifest->() or return;
+        my $entry = $m->{$template};
         return unless $entry;
-        return if $is_child_entry{$template};
+        return if $is_child_entry->{$template};
         # Idempotency guard for nested renders. A controller might
         # call `render_to_string` inside an action and then `render`
         # — without this we'd re-init `bf` on the second pass and
@@ -72,7 +108,7 @@ sub register ($self, $app, $config = {}) {
         $c->stash->{'bf.auto_init_done'} = 1;
 
         $bf->_scope_id($template . '_' . substr(rand() =~ s/^0\.//r, 0, 6));
-        $bf->register_components_from_manifest($manifest);
+        $bf->register_components_from_manifest($m);
 
         # Seed each ssrDefault into the stash unless the caller has
         # already supplied a value for that key — callers always win.
@@ -98,20 +134,6 @@ sub register ($self, $app, $config = {}) {
     });
 }
 
-sub _load_manifest ($app, $config) {
-    return undef if exists $config->{manifest_path} && !defined $config->{manifest_path};
-    my $manifest_path = $config->{manifest_path}
-        // $app->home->child('dist/templates/manifest.json');
-    my $file = path($manifest_path);
-    return undef unless -r $file;
-    my $manifest = eval { decode_json($file->slurp) };
-    if ($@ || ref($manifest) ne 'HASH') {
-        $app->log->warn("BarefootJS: cannot parse manifest at $file: $@") if $@;
-        return undef;
-    }
-    return $manifest;
-}
-
 1;
 __END__
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@barefootjs/mojolicious",
-  "version": "0.17.1",
+  "version": "0.18.1",
   "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.17.1"
+    "@barefootjs/shared": "0.18.1"
   },
   "peerDependencies": {
     "@barefootjs/jsx": ">=0.2.0",
@@ -60,6 +60,6 @@
   },
   "devDependencies": {
     "@barefootjs/adapter-tests": "0.1.0",
-    "@barefootjs/jsx": "0.17.1"
+    "@barefootjs/jsx": "0.18.1"
   }
 }

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,137 +23,21 @@ 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' }],
-    // #2038: a filter predicate containing a nested `.find(...)` callback.
-    // `find*` returns an element, not a boolean — there is no inline grep
-    // form, and the emitter used to degrade the call to its receiver.
-    // The nested `.some` sibling (`filter-nested-callback-predicate`) is
-    // NOT pinned: Mojo lowers it to a real inline Perl `grep` and must
-    // render to Hono parity instead.
-    // https://github.com/piconic-ai/barefootjs/issues/2038
-    'filter-nested-find-predicate': [{ 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'`).
-    // #2073 follow-up: a function-reference `.map(format)` callback has no
-    // arrow body to serialize — not a CALLBACK_METHODS shape — so the
-    // UNSUPPORTED_METHODS gate refuses it with BF101 rather than emitting
-    // a broken template.
-    'array-map-function-reference': [{ code: 'BF101', severity: 'error' }],
-  },
-  // `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,
-  ]),
+  // 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
@@ -1859,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) {
@@ -1883,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)
+  })
+})