@barefootjs/mojolicious 0.1.0

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

@@ -0,0 +1,136 @@
+/**
+ * MojoAdapter - Streaming SSR Tests
+ *
+ * Tests the renderAsync method and streaming-related output.
+ */
+
+import { describe, test, expect } from 'bun:test'
+import { MojoAdapter } from '../adapter/mojo-adapter'
+import type { IRAsync, IRElement, IRComponent } from '@barefootjs/jsx'
+
+describe('MojoAdapter - Streaming SSR', () => {
+  const adapter = new MojoAdapter()
+
+  const loc = { file: '', start: { line: 1, column: 0 }, end: { line: 1, column: 0 } } as const
+
+  function asyncNode(id: string, fallbackText: string): IRAsync {
+    return {
+      type: 'async',
+      id,
+      fallback: {
+        type: 'element',
+        tag: 'p',
+        attrs: [],
+        events: [],
+        ref: null,
+        children: [{ type: 'text', value: fallbackText, loc }],
+        slotId: null,
+        needsScope: false,
+        loc,
+      } as IRElement,
+      children: [
+        {
+          type: 'component',
+          name: 'ProductDetail',
+          props: [],
+          template: 'ProductDetail',
+          slotId: null,
+          children: [],
+          loc,
+        } as IRComponent,
+      ],
+      loc,
+    }
+  }
+
+  test('renderAsync generates bf->async_boundary call with fallback', () => {
+    const output = adapter.renderAsync(asyncNode('a0', 'Loading...'))
+
+    // Should contain the async_boundary call with the ID
+    expect(output).toContain("async_boundary('a0'")
+    // Should contain the fallback content
+    expect(output).toContain('Loading...')
+  })
+
+  // #1298: the previous renderAsync emitted
+  //   `<%== bf->async_boundary('a0', begin %>…<% end) %>`
+  // which split the call across template-text and `<%== %>` regions —
+  // the inner `%>` closed the outer interpolation, leaving the trailing
+  // `)` in plain template text and breaking Mojo's lexer. The fix is to
+  // capture the fallback into a CODE ref in its own action and pass the
+  // variable to async_boundary. These tests pin the structural
+  // invariants of the captured-variable shape so a regression to the
+  // inlined form (or any shape that re-introduces unbalanced `%>`)
+  // fails here, not at template-parse time.
+  describe('renderAsync emits balanced Mojo syntax (#1298)', () => {
+    test('captures fallback into its own `begin %>…<% end %>` action before calling async_boundary', () => {
+      const output = adapter.renderAsync(asyncNode('a0', 'Loading...'))
+
+      // A capture action precedes the call.
+      expect(output).toMatch(/<%\s*my\s+\$bf_async_fallback_a0\s*=\s*begin\s*%>/)
+      expect(output).toContain('<% end %>')
+      // The call site references the variable, not an inlined `begin`.
+      expect(output).toMatch(/<%==\s*bf->async_boundary\('a0',\s*\$bf_async_fallback_a0\s*\)\s*%>/)
+      // No nested `begin` inside the `<%== ... %>` block — that was the
+      // exact malformation #1298 fixed.
+      expect(output).not.toMatch(/<%==\s*bf->async_boundary\([^)]*begin/)
+    })
+
+    test('every `<%` / `<%==` opener has a matching `%>` closer', () => {
+      const output = adapter.renderAsync(asyncNode('a0', 'Loading...'))
+
+      // Count `<%`-prefixed openers (including `<%==`) vs `%>` closers.
+      // Unbalanced counts indicate a stray `%>` (the #1298 failure mode)
+      // or a stray opener.
+      const openers = (output.match(/<%/g) ?? []).length
+      const closers = (output.match(/%>/g) ?? []).length
+      expect(openers).toBe(closers)
+    })
+
+    test('multiple <Async> boundaries get distinct capture variable names', () => {
+      const a = adapter.renderAsync(asyncNode('a0', 'first'))
+      const b = adapter.renderAsync(asyncNode('a1', 'second'))
+
+      expect(a).toContain('$bf_async_fallback_a0')
+      expect(b).toContain('$bf_async_fallback_a1')
+      // Cross-contamination would let one boundary's resolve overwrite
+      // another's fallback variable on the page.
+      expect(a).not.toContain('$bf_async_fallback_a1')
+      expect(b).not.toContain('$bf_async_fallback_a0')
+    })
+  })
+
+  test('renderNode dispatches async type correctly', () => {
+    const asyncNode: IRAsync = {
+      type: 'async',
+      id: 'a1',
+      fallback: {
+        type: 'text',
+        value: 'Please wait...',
+        loc: { file: '', start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+      },
+      children: [],
+      loc: { file: '', start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+    }
+
+    const output = adapter.renderNode(asyncNode)
+
+    expect(output).toContain("'a1'")
+    expect(output).toContain('Please wait...')
+  })
+
+  test('renderNode dispatches provider type (transparent)', () => {
+    const providerNode = {
+      type: 'provider' as const,
+      contextName: 'ThemeContext',
+      valueProp: { name: 'value', value: 'dark', dynamic: false },
+      children: [
+        { type: 'text' as const, value: 'child content', loc: { file: '', start: { line: 1, column: 0 }, end: { line: 1, column: 0 } } },
+      ],
+      loc: { file: '', start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+    }
+
+    const output = adapter.renderNode(providerNode)
+    expect(output).toBe('child content')
+  })
+})

package/src/__tests__/scaffold.test.ts

@@ -0,0 +1,224 @@
+// Specification-as-test for `bun create barefootjs --adapter mojo <project-name>`.
+//
+// This file verifies that the Mojo scaffold satisfies both the
+// cross-adapter contract defined in `create-barefootjs` and the
+// Mojo-specific wiring:
+//
+//   - `barefoot.config.ts` targets `@barefootjs/mojolicious/build` and
+//     uses `clientJsBasePath: '/static/components/'`.
+//   - `app.pl` forwards `/static/*` URLs to the on-disk static paths
+//     (Mojolicious's built-in dispatcher does not honour URL prefixes,
+//     so the explicit routes are load-bearing — without them every
+//     stylesheet and client bundle 404s in the browser).
+//   - `lib/BarefootJS.pm` is vendored, `cpanfile` lists Mojolicious,
+//     and `app.pl` uses `register_components_from_manifest` so the
+//     manifest-driven child rendering works without per-component wire-up.
+//
+//   BAREFOOT_CREATE_INTEGRATION=1 bun test src/__tests__/scaffold.test.ts
+
+import { describe, test, expect, beforeAll } from 'bun:test'
+import { existsSync, readFileSync } from 'node:fs'
+import path from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { mkdtempSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { fileURLToPath } from 'node:url'
+import {
+  assertScaffoldContract,
+  ensureCreateCli,
+  type ScaffoldFacts,
+} from '@barefootjs/adapter-tests'
+
+// ---------------------------------------------------------------------------
+// Helpers (thin wrappers around the compiled create-barefootjs CLI)
+// ---------------------------------------------------------------------------
+
+const CREATE_PKG_DIR = path.join(
+  fileURLToPath(new URL('.', import.meta.url)),
+  '../../../create-barefootjs',
+)
+const CREATE_CLI = path.join(CREATE_PKG_DIR, 'dist', 'index.js')
+
+function mktmp(): string {
+  return mkdtempSync(path.join(tmpdir(), 'bf-mojo-scaffold-test-'))
+}
+
+interface RunResult {
+  exitCode: number | null
+  stdout: string
+  stderr: string
+}
+
+function runCreate(
+  args: string[],
+  opts: { cwd: string; env?: Record<string, string> },
+): RunResult {
+  ensureCreateCli(CREATE_PKG_DIR)
+  const result = spawnSync('node', [CREATE_CLI, ...args], {
+    cwd: opts.cwd,
+    env: {
+      ...process.env,
+      ...opts.env,
+      npm_config_user_agent: undefined,
+    },
+    encoding: 'utf-8',
+  })
+  return {
+    exitCode: result.status,
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? '',
+  }
+}
+
+const INTEGRATION = process.env.BAREFOOT_CREATE_INTEGRATION === '1'
+
+// ---------------------------------------------------------------------------
+// Happy-path scenario — `bun create barefootjs --adapter mojo mojo-app`
+// ---------------------------------------------------------------------------
+
+describe.skipIf(!INTEGRATION)(
+  'Scenario: bun create barefootjs --adapter mojo <project-name>',
+  () => {
+    let result: RunResult
+    let projectDir: string
+
+    beforeAll(() => {
+      const cwd = mktmp()
+      result = runCreate(['mojo-app', '--adapter', 'mojo'], { cwd })
+      projectDir = path.join(cwd, 'mojo-app')
+    })
+
+    test('satisfies the cross-adapter scaffold contract', () => {
+      const app = readFileSync(path.join(projectDir, 'app.pl'), 'utf-8')
+      assertScaffoldContract({
+        exitCode: result.exitCode,
+        stdout: result.stdout,
+        projectDir,
+        adapterPackageName: '@barefootjs/mojolicious',
+        devReload: {
+          // The `BarefootJS::DevReload` plugin registers `/_bf/reload` as
+          // an SSE endpoint and exposes `bf_dev_snippet` to embed the
+          // reload subscriber in the layout. The plugin self-disables when
+          // `app->mode eq 'production'`, so the production gate is
+          // handled at the library layer.
+          subscribesBrowserInDev:
+            app.includes("plugin 'BarefootJS::DevReload'") &&
+            app.includes('bf_dev_snippet'),
+          gatedToDev: true,
+          sentinelSseEndpoint: '/_bf/reload',
+        },
+      } satisfies ScaffoldFacts)
+    })
+
+    // -------------------------------------------------------------------------
+    // Mojo-specific: static asset routing
+    // -------------------------------------------------------------------------
+
+    describe('app.pl serves static assets', () => {
+      // Mojolicious's built-in static dispatcher does not honour URL
+      // prefixes. The scaffold's `barefoot.config.ts` and layout `<link>`s
+      // all reference `/static/*` URLs, so `app.pl` needs explicit
+      // forwarding routes — without them every stylesheet and client bundle
+      // 404s in the browser even though the SSR HTML rendered correctly.
+      test('forwards /static/components/* to dist/client/* (clientJsBasePath)', () => {
+        const app = readFileSync(path.join(projectDir, 'app.pl'), 'utf-8')
+        expect(app).toMatch(/get\s+'\/static\/components\/\*asset'/)
+        expect(app).toContain("reply->static('client/'")
+      })
+
+      test('forwards /static/* to public/* (handwritten stylesheets)', () => {
+        const app = readFileSync(path.join(projectDir, 'app.pl'), 'utf-8')
+        expect(app).toMatch(/get\s+'\/static\/\*asset'/)
+      })
+
+      test('mounts public/ and dist/ on app->static->paths', () => {
+        const app = readFileSync(path.join(projectDir, 'app.pl'), 'utf-8')
+        expect(app).toContain("app->home->child('public')")
+        expect(app).toContain("app->home->child('dist')")
+      })
+    })
+
+    // -------------------------------------------------------------------------
+    // Mojo-specific: plugin wiring and Perl deps
+    // -------------------------------------------------------------------------
+
+    describe('mojo wiring', () => {
+      test('lib/BarefootJS.pm is vendored', () => {
+        expect(existsSync(path.join(projectDir, 'lib', 'BarefootJS.pm'))).toBe(true)
+      })
+
+      test('lib/Mojolicious/Plugin/BarefootJS/DevReload.pm is vendored', () => {
+        // The dev-reload plugin lives under a nested namespace so
+        // `plugin 'BarefootJS::DevReload'` resolves to its file. A
+        // missing vendor copy would crash app.pl at boot.
+        expect(
+          existsSync(
+            path.join(projectDir, 'lib', 'Mojolicious', 'Plugin', 'BarefootJS', 'DevReload.pm'),
+          ),
+        ).toBe(true)
+      })
+
+      test('cpanfile lists Mojolicious', () => {
+        const cp = readFileSync(path.join(projectDir, 'cpanfile'), 'utf-8')
+        expect(cp).toMatch(/Mojolicious/)
+      })
+
+      test('plugin auto-loads manifest — no per-route register_components_from_manifest call', () => {
+        // After #1416, `Mojolicious::Plugin::BarefootJS` reads the
+        // build manifest at plugin-register time and installs a
+        // `before_render` hook that wires up child renderers and
+        // seeds the stash automatically. The scaffold's `app.pl`
+        // therefore no longer mentions either symbol directly — the
+        // user can `bf add <component>` and refresh the browser
+        // without touching the Perl file.
+        const app = readFileSync(path.join(projectDir, 'app.pl'), 'utf-8')
+        expect(app).not.toContain('register_components_from_manifest')
+        expect(app).not.toContain("app->home->child('dist/templates/manifest.json')")
+      })
+
+      test('barefoot.config.ts targets the mojolicious adapter', () => {
+        const cfg = readFileSync(path.join(projectDir, 'barefoot.config.ts'), 'utf-8')
+        expect(cfg).toContain("from '@barefootjs/mojolicious/build'")
+        expect(cfg).toContain("clientJsBasePath: '/static/components/'")
+      })
+
+      test('layout stylesheets point at /static/*.css', () => {
+        // The forwarding `/static/*asset` route serves these from
+        // `public/`, so the `<link href>`s in the rendered HTML must
+        // match. A drift here would make every page render unstyled.
+        const app = readFileSync(path.join(projectDir, 'app.pl'), 'utf-8')
+        expect(app).toContain('/static/tokens.css')
+        expect(app).toContain('/static/styles.css')
+        expect(app).toContain('/static/uno.css')
+      })
+    })
+
+    // -------------------------------------------------------------------------
+    // Mojo-specific: dev-reload wiring (detailed)
+    // -------------------------------------------------------------------------
+
+    describe('dev reload wiring', () => {
+      test('app.pl registers the DevReload plugin', () => {
+        const app = readFileSync(path.join(projectDir, 'app.pl'), 'utf-8')
+        expect(app).toContain("plugin 'BarefootJS::DevReload'")
+      })
+
+      test('layout calls bf_dev_snippet inside <body>', () => {
+        // Snippet must land inside `<body>` so the inline `<script>`
+        // executes after the page elements are parsed; emitting it
+        // in `<head>` would race scroll-restoration against the page content.
+        const app = readFileSync(path.join(projectDir, 'app.pl'), 'utf-8')
+        const body = app.match(/<body>([\s\S]*?)<\/body>/)?.[1] ?? ''
+        expect(body).toContain('bf_dev_snippet')
+      })
+    })
+
+    // -------------------------------------------------------------------------
+    // Next-step instructions
+    // -------------------------------------------------------------------------
+
+    test('the printed next-step uses the chosen target directory', () => {
+      expect(result.stdout).toContain('cd mojo-app')
+    })
+  },
+)

package/src/__tests__/template-base-name.test.ts

@@ -0,0 +1,26 @@
+import { describe, test, expect } from 'bun:test'
+import { templateBaseName } from '../test-render'
+
+describe('templateBaseName (#1297)', () => {
+  test('strips Mojo adapter `.html.ep` extension, not just the last dot segment', () => {
+    // The crux of the #1297 follow-up: a naive `/\.[^.]+$/` would leave
+    // `Counter.html` here, which would miss the `irsByName` lookup
+    // (componentName is `Counter`) and pair every sibling template to
+    // the entry-point IR.
+    expect(templateBaseName('component/Counter.html.ep', '.html.ep')).toBe('Counter')
+    expect(templateBaseName('theme/ThemeLabel.html.ep', '.html.ep')).toBe('ThemeLabel')
+    expect(templateBaseName('src/very/nested/path/Outer.html.ep', '.html.ep')).toBe('Outer')
+  })
+
+  test('works for single-segment extensions too', () => {
+    expect(templateBaseName('dir/Counter.tmpl', '.tmpl')).toBe('Counter')
+  })
+
+  test('returns the bare filename when the extension does not match', () => {
+    expect(templateBaseName('dir/Counter.txt', '.html.ep')).toBe('Counter.txt')
+  })
+
+  test('handles paths with no directory component', () => {
+    expect(templateBaseName('Counter.html.ep', '.html.ep')).toBe('Counter')
+  })
+})

package/src/adapter/__tests__/boolean-result.test.ts

@@ -0,0 +1,106 @@
+import { describe, test, expect } from 'bun:test'
+import { isAriaBooleanAttr, isBooleanResultExpr } from '../boolean-result'
+
+describe('isBooleanResultExpr', () => {
+  describe('detected as boolean-result', () => {
+    test.each([
+      // Top-level comparison
+      ['count() > 0'],
+      ['x === y'],
+      ['a !== b'],
+      ['x >= 10'],
+      ['a == b'],
+      // Unary logical NOT
+      ['!accepted()'],
+      ['!ok'],
+      // Boolean literals
+      ['true'],
+      ['false'],
+      // Logical combinator with both sides boolean
+      ['x > 0 && y < 10'],
+      ['!a || b === c'],
+      // Conditional with both branches boolean
+      ['cond ? true : false'],
+      ['x > 0 ? x === 1 : !y'],
+    ])('"%s" is boolean-result', expr => {
+      expect(isBooleanResultExpr(expr)).toBe(true)
+    })
+  })
+
+  describe('not boolean-result', () => {
+    test.each([
+      // Bare identifier — could be anything; the adapter has no
+      // type info from source text. Leave unwrapped.
+      ['accepted'],
+      ['count'],
+      // Call expression — same reason.
+      ['accepted()'],
+      ['user.isAdmin()'],
+      // Member access
+      ['props.checked'],
+      // Numeric / string / null literal
+      ['0'],
+      ['"hello"'],
+      ['null'],
+      // Template literal (handled by a separate emit path)
+      ['`${name}`'],
+      // Logical fallback whose right side is non-boolean — `||
+      // 'fallback'` returns a string, not a boolean
+      ['x() || "fallback"'],
+      // Conditional with non-boolean branches
+      ['cond ? "yes" : "no"'],
+      ['ok() ? count() : 0'],
+      // Arithmetic — `+` is not a comparison
+      ['a + b'],
+    ])('"%s" is NOT boolean-result', expr => {
+      expect(isBooleanResultExpr(expr)).toBe(false)
+    })
+  })
+
+  test('returns false for unparseable input', () => {
+    // `parseExpression` always returns a `ParsedExpr` — for shapes it
+    // can't categorise it lands on `{ kind: 'unsupported' }`, which
+    // the classifier falls through to the default case and declines
+    // to wrap. The contract here is "do not throw, do not wrap".
+    expect(isBooleanResultExpr('???invalid<<')).toBe(false)
+  })
+})
+
+describe('isAriaBooleanAttr', () => {
+  test.each([
+    // Strict boolean state.
+    'aria-atomic',
+    'aria-busy',
+    'aria-disabled',
+    'aria-hidden',
+    'aria-modal',
+    'aria-multiline',
+    'aria-multiselectable',
+    'aria-readonly',
+    'aria-required',
+    // Tri-state.
+    'aria-checked',
+    'aria-pressed',
+  ])('%s is recognised as ARIA boolean', (name) => {
+    expect(isAriaBooleanAttr(name)).toBe(true)
+  })
+
+  test.each([
+    // String-valued / token-valued ARIA attributes — wrapping with
+    // `bool_str` would coerce a user-supplied string to "true"/"false".
+    'aria-label',
+    'aria-labelledby',
+    'aria-describedby',
+    'aria-current', // page | step | location | … | true | false
+    'aria-sort', // ascending | descending | none | other
+    'aria-haspopup', // false | true | menu | listbox | tree | grid | dialog
+    'aria-invalid', // false | true | grammar | spelling
+    // Non-ARIA attributes — should also fall through.
+    'disabled',
+    'data-active',
+    'class',
+    'id',
+  ])('%s is NOT recognised as ARIA boolean', (name) => {
+    expect(isAriaBooleanAttr(name)).toBe(false)
+  })
+})

package/src/adapter/boolean-result.ts

@@ -0,0 +1,126 @@
+/**
+ * Structural classifier for JS expressions whose result is a boolean
+ * value (or unambiguously stringifies to "true"/"false" in JS).
+ *
+ * Used by the Mojo adapter's `emitExpression` to decide whether to
+ * route a reactive attribute binding through the `bf->bool_str` Perl
+ * runtime helper (#1466 follow-up). Perl has no native boolean type;
+ * `($count > 0)` evaluates to `''` / `1`, not `"false"` / `"true"`,
+ * so the literal stringification diverges from Hono / Go. Wrapping
+ * the value with `bool_str` realigns the serialised attribute with
+ * JS `String(boolean)` semantics.
+ *
+ * The classifier walks a `ParsedExpr` produced by
+ * `@barefootjs/jsx::parseExpression` — same AST the filter / loop
+ * lowerings already use — so detection is structural rather than
+ * regex-text-matching. Wrapped expression text is left to the
+ * caller's existing `convertExpressionToPerl` pipeline; this module
+ * only decides whether to wrap.
+ *
+ * Detected shapes:
+ *   - `binary` with a comparison operator (`<`, `>`, `<=`, `>=`,
+ *     `==`, `===`, `!=`, `!==`)
+ *   - `unary` with logical `!`
+ *   - `literal` with `literalType: 'boolean'`
+ *   - `logical` (`&&` / `||` / `??`) when both sides are themselves
+ *     boolean-result (catches `x > 0 && y < 10`; intentionally does
+ *     NOT catch `x() || 'fallback'` whose right side stringifies as
+ *     a regular value)
+ *   - `conditional` (`?:`) when both branches are themselves
+ *     boolean-result
+ *
+ * Anything else returns `false` — including bare identifiers
+ * (`accepted`) and call expressions (`accepted()`) whose return type
+ * the adapter has no way to infer from source text alone. Those
+ * carry their own (Perl-coerced) value through unchanged, which
+ * stays correct for non-boolean shapes and is handled by
+ * `normalizeHTML`'s `aria-*="0"` rule for the specific Mojo-Perl
+ * `aria-*={booleanFn()}` divergence.
+ */
+
+import { parseExpression, type ParsedExpr } from '@barefootjs/jsx'
+
+const COMPARISON_OPS = new Set([
+  '<',
+  '>',
+  '<=',
+  '>=',
+  '==',
+  '===',
+  '!=',
+  '!==',
+])
+
+function isBooleanResultParsed(node: ParsedExpr): boolean {
+  switch (node.kind) {
+    case 'literal':
+      return node.literalType === 'boolean'
+    case 'binary':
+      return COMPARISON_OPS.has(node.op)
+    case 'unary':
+      return node.op === '!'
+    case 'logical':
+      // `x > 0 && y < 10` is boolean; `x() || 'fallback'` is not.
+      // Only both-sides-boolean qualifies.
+      return (
+        isBooleanResultParsed(node.left) && isBooleanResultParsed(node.right)
+      )
+    case 'conditional':
+      // `cond ? bool : bool` is boolean; `cond ? 'a' : 'b'` is not.
+      return (
+        isBooleanResultParsed(node.consequent) &&
+        isBooleanResultParsed(node.alternate)
+      )
+    default:
+      return false
+  }
+}
+
+export function isBooleanResultExpr(expr: string): boolean {
+  const parsed = parseExpression(expr.trim())
+  if (!parsed) return false
+  return isBooleanResultParsed(parsed)
+}
+
+/**
+ * ARIA attributes whose spec values are `"true"`, `"false"`, and (for
+ * tri-state members) `"mixed"`. When a fixture binds one of these to
+ * an arbitrary JS expression (`aria-checked={accepted()}`), the
+ * expression's actual type isn't recoverable from source text — but
+ * the attribute name itself witnesses that the binding is
+ * boolean-shaped. Routing these through `bf->bool_str` produces the
+ * spec-canonical `"true"` / `"false"` even when the expression is
+ * opaque, eliminating the Mojo-only `aria-*="0"` divergence at the
+ * source rather than papering it over in `normalizeHTML`.
+ *
+ * Deliberately conservative — only includes ARIA attributes whose
+ * spec value set is exactly `true | false` or `true | false | mixed`.
+ * Tokenised ARIA attributes (`aria-current` is `page | step | …`,
+ * `aria-sort` is `ascending | descending | …`) are intentionally
+ * excluded so a string-valued binding doesn't get coerced to
+ * `"true"` / `"false"`.
+ */
+const ARIA_BOOLEAN_ATTRS = new Set([
+  // Strict boolean state (true | false; some allow `undefined` =
+  // attribute absent, which the runtime emits as no-attr regardless).
+  'aria-atomic',
+  'aria-busy',
+  'aria-disabled',
+  'aria-hidden',
+  'aria-modal',
+  'aria-multiline',
+  'aria-multiselectable',
+  'aria-readonly',
+  'aria-required',
+  // Tri-state (true | false | mixed). The `bool_str` helper only
+  // maps Perl truthy / falsy to true / false — a fixture that wants
+  // the literal `"mixed"` would bind a string-valued JSX attr
+  // (`aria-checked="mixed"`), which lowers through the `literal` emit
+  // path and never touches this code.
+  'aria-checked',
+  'aria-pressed',
+])
+
+export function isAriaBooleanAttr(name: string): boolean {
+  return ARIA_BOOLEAN_ATTRS.has(name)
+}

package/src/adapter/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Mojolicious EP Template Adapter Exports
+ */
+
+export { MojoAdapter, mojoAdapter } from './mojo-adapter'
+export type { MojoAdapterOptions } from './mojo-adapter'