@barefootjs/mojolicious 0.18.3 → 0.18.5

package/package.json

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

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

@@ -1163,7 +1163,7 @@ export function Foo(props: { v: string }) {
     // list rather than replace.
     const a = new MojoAdapter()
     const keys = Object.keys(a.templatePrimitives ?? {}).sort()
-    expect(keys).toEqual(['JSON.stringify', 'Math.ceil', 'Math.floor', 'Math.round', 'Number', 'String'])
+    expect(keys).toEqual(['JSON.stringify', 'Math.abs', 'Math.ceil', 'Math.floor', 'Math.max', 'Math.min', 'Math.round', 'Number', 'String'])
   })
 
   test('unregistered identifier-path callee is NOT accepted', () => {
@@ -1902,3 +1902,23 @@ export function C() {
     expect(deferred.template).not.toContain('data-x')
   })
 })
+
+describe('MojoAdapter - named-slot capture identifier safety (#2168 jsx-element-prop)', () => {
+  // A JSX-valued prop under a hyphenated name (`data-slot`, a valid JSX
+  // attribute name) must not leak into the `begin %>...<% end` capture
+  // variable — Perl variable tokens can't contain `-`. The capture
+  // variable is purely counter-based (never derived from the prop name);
+  // the hash KEY passed to `render_child` still carries the real name,
+  // quoted via `perlHashKey`.
+  test('a hyphenated prop name does not appear in the capture variable', () => {
+    const { template } = compileAndGenerate(`
+function Card(props) { return null }
+export function Parent() {
+  return <Card data-slot={<strong>Title</strong>}>text</Card>
+}
+`)
+    expect(template).toContain('<% my $bf_prop_0 = begin %>')
+    expect(template).toContain("'data-slot' => $bf_prop_0")
+    expect(template).not.toContain('$bf_prop_data')
+  })
+})

package/src/adapter/expr/array-method.ts

@@ -139,6 +139,15 @@ export function renderArrayMethod(
       const recv = emit(object)
       return `bf->trim(${recv})`
     }
+    case 'trimStart':
+    case 'trimEnd': {
+      // `.trimStart()` / `.trimEnd()` — the one-sided siblings of
+      // `.trim()` (#2183 follow-up). Dedicated `bf->trim_start` /
+      // `bf->trim_end` helpers, not `bf->trim` with a flag.
+      const fn = method === 'trimStart' ? 'trim_start' : 'trim_end'
+      const recv = emit(object)
+      return `bf->${fn}(${recv})`
+    }
     case 'toFixed': {
       // `.toFixed(digits?)` — Number → fixed-decimal string. `bf->to_fixed`
       // mirrors JS rounding + zero-padding (default 0 digits). #1897.
@@ -195,6 +204,16 @@ export function renderArrayMethod(
       const newS = emit(args[1])
       return `bf->replace(${recv}, ${oldS}, ${newS})`
     }
+    case 'replaceAll': {
+      // `.replaceAll(old, new)` — string-pattern form, EVERY occurrence,
+      // via the dedicated `bf->replace_all` helper (not `bf->replace`
+      // with a flag) — the regex-pattern form is refused upstream at
+      // the parser, same as `.replace`. See #2182.
+      const recv = emit(object)
+      const oldS = emit(args[0])
+      const newS = emit(args[1])
+      return `bf->replace_all(${recv}, ${oldS}, ${newS})`
+    }
     case 'repeat': {
       // `.repeat(n)` — string repeated `n` times. The `bf->repeat`
       // helper wraps Perl's `x` operator with the same negative-count

package/src/adapter/expr/emitters.ts

@@ -11,7 +11,9 @@
  *     adapter only through the narrow `MojoEmitContext` seam.
  */
 
-import {
+import { groupBinaryOperand,
+  isStringTypedOperand,
+  isStringConcatBinary,
   type ParsedExprEmitter,
   type HigherOrderMethod,
   type ArrayMethod,
@@ -29,7 +31,7 @@ import {
 
 import type { MojoEmitContext } from '../emit-context.ts'
 import { MOJO_TEMPLATE_PRIMITIVES } from '../lib/constants.ts'
-import { emitIndexAccessPerl, isStringTypedOperand } from './operand.ts'
+import { emitIndexAccessPerl } from './operand.ts'
 import {
   renderArrayMethod,
   renderSortMethod,
@@ -103,7 +105,7 @@ export class MojoFilterEmitter implements ParsedExprEmitter {
     return String(value)
   }
 
-  member(object: ParsedExpr, property: string, _computed: boolean, emit: (e: ParsedExpr) => string): string {
+  member(object: ParsedExpr, property: string, _computed: boolean, _optional: boolean, emit: (e: ParsedExpr) => string): string {
     // `.length` on a higher-order result (e.g.
     // `x.tags.filter(t => t.active).length > 0` inside the outer
     // filter predicate, #1443). The higher-order emit produces an
@@ -141,8 +143,11 @@ export class MojoFilterEmitter implements ParsedExprEmitter {
   }
 
   binary(op: string, left: ParsedExpr, right: ParsedExpr, emit: (e: ParsedExpr) => string): string {
-    const l = emit(left)
-    const r = emit(right)
+    // Preserve source grouping: a compound operand re-emitted as infix
+    // text is otherwise re-parsed under THIS language's precedence —
+    // `(count() + 2) * 3` would silently become `count + 2 * 3` (#2173).
+    const l = groupBinaryOperand(left, emit(left))
+    const r = groupBinaryOperand(right, emit(right))
     // String equality: `eq`/`ne` when EITHER operand is string-typed — a string
     // literal, a string signal getter, or a string prop. Numeric `==`/`!=`
     // would coerce both sides to 0 and match unrelated non-numeric strings (#1672).
@@ -154,6 +159,12 @@ export class MojoFilterEmitter implements ParsedExprEmitter {
     if ((op === '!==' || op === '!=') && stringCmp) {
       return `${l} ne ${r}`
     }
+    // JS `+` with a string-typed operand is CONCATENATION, not addition —
+    // Perl's numeric `+` coerces `'Hello, ' + $name` to 0 (#2176). Lower
+    // to Perl's `.` concat operator.
+    if (isStringConcatBinary(op, left, right, this.isStringName)) {
+      return `${l} . ${r}`
+    }
     const opMap: Record<string, string> = {
       '===': '==', '!==': '!=', '>': '>', '<': '<', '>=': '>=', '<=': '<=',
       '+': '+', '-': '-', '*': '*', '/': '/',
@@ -311,7 +322,7 @@ export class MojoTopLevelEmitter implements ParsedExprEmitter {
     return String(value)
   }
 
-  member(object: ParsedExpr, property: string, _computed: boolean, emit: (e: ParsedExpr) => string): string {
+  member(object: ParsedExpr, property: string, _computed: boolean, _optional: boolean, emit: (e: ParsedExpr) => string): string {
     // `props.x` flattens to the bare `$x` the Mojo SSR caller binds each
     // prop to (props arrive as individual `my $x = ...` vars, not a
     // `$props` hashref).
@@ -327,7 +338,22 @@ export class MojoTopLevelEmitter implements ParsedExprEmitter {
       if (staticValue !== null) return staticValue
     }
     const obj = emit(object)
-    if (property === 'length') return `scalar(@{${obj}})`
+    if (property === 'length') {
+      // `.length` dispatches on receiver type: a STRING receiver needs
+      // Perl's scalar `length($x)`, while the array lowering
+      // `scalar(@{$x})` dereferences the value as an array ref and
+      // returns 0 for a scalar string (the `string-length-text`
+      // divergence). The receiver is string-typed when it's a known
+      // string prop/getter (`isStringTypedOperand`) or a bare
+      // identifier bound to one — the same `_isStringValueName` witness
+      // the `eq`/concat lowering already consults.
+      const isStr = (e: ParsedExpr) => isStringTypedOperand(e, n => this.ctx._isStringValueName(n))
+      const isStringReceiver =
+        isStr(object) ||
+        (object.kind === 'identifier' && this.ctx._isStringValueName(object.name))
+      if (isStringReceiver) return `length(${obj})`
+      return `scalar(@{${obj}})`
+    }
     return `${obj}->{${property}}`
   }
 
@@ -389,8 +415,11 @@ export class MojoTopLevelEmitter implements ParsedExprEmitter {
   }
 
   binary(op: string, left: ParsedExpr, right: ParsedExpr, emit: (e: ParsedExpr) => string): string {
-    const l = emit(left)
-    const r = emit(right)
+    // Preserve source grouping: a compound operand re-emitted as infix
+    // text is otherwise re-parsed under THIS language's precedence —
+    // `(count() + 2) * 3` would silently become `count + 2 * 3` (#2173).
+    const l = groupBinaryOperand(left, emit(left))
+    const r = groupBinaryOperand(right, emit(right))
     // String equality: `eq`/`ne` when EITHER operand is string-typed — a string
     // literal (`role() === 'admin'`), a string signal getter (`sel()`), or a
     // string prop (`props.x`). Falling back to numeric `==`/`!=` would make
@@ -404,6 +433,12 @@ export class MojoTopLevelEmitter implements ParsedExprEmitter {
     if ((op === '!==' || op === '!=') && stringCmp) {
       return `${l} ne ${r}`
     }
+    // JS `+` with a string-typed operand is CONCATENATION, not addition —
+    // Perl's numeric `+` coerces `'Hello, ' + $name` to 0 (#2176). Lower
+    // to Perl's `.` concat operator.
+    if (isStringConcatBinary(op, left, right, n => this.ctx._isStringValueName(n))) {
+      return `${l} . ${r}`
+    }
     const opMap: Record<string, string> = {
       '===': '==', '!==': '!=', '>': '>', '<': '<', '>=': '>=', '<=': '<=',
       '+': '+', '-': '-', '*': '*',

package/src/adapter/expr/operand.ts

@@ -1,39 +1,18 @@
 /**
- * Operand-type classification + index-access lowering for the Mojolicious
- * EP template adapter.
+ * Index-access lowering for the Mojolicious EP template adapter.
  *
  * Extracted from `mojo-adapter.ts` (domain-module refactor, issue #2018
- * track D). Pure functions over `ParsedExpr` — they take an `isStringName`
+ * track D). Pure function over `ParsedExpr` — it takes an `isStringName`
  * predicate (supplied by the emitter from adapter state) rather than reading
  * adapter instance state directly.
  *
- * SHARED CANDIDATE: `isStringTypedOperand` is byte-identical to the Xslate
- * adapter's copy and is adapter-agnostic — an extraction candidate for a
- * shared Perl-family codegen module (groundwork for the future Perl evaluator
- * integration, issue #2018 track D). `emitIndexAccessPerl` stays Mojo-specific
+ * The string-typed-operand classifier that used to live here (marked
+ * SHARED CANDIDATE) was promoted to `@barefootjs/jsx` as
+ * `isStringTypedOperand` (#2176); `emitIndexAccessPerl` stays Mojo-specific
  * (Perl's `->[]` vs `->{}` split has no Kolon equivalent).
  */
 
-import type { ParsedExpr } from '@barefootjs/jsx'
-
-/**
- * Whether a comparison operand is string-typed, so JS `===`/`!==` against it
- * must lower to Perl `eq`/`ne` instead of numeric `==`/`!=` (#1672). Covers a
- * string literal, a string-signal getter call (`sel()`), and a string prop
- * access (`props.x`). `isStringName` reports whether a getter/prop name is
- * known-string. Loop-element fields (`t.id`) on untyped arrays have no known
- * type and stay undetected — a separate, narrower gap.
- */
-export function isStringTypedOperand(expr: ParsedExpr, isStringName: (n: string) => boolean): boolean {
-  if (expr.kind === 'literal' && expr.literalType === 'string') return true
-  if (expr.kind === 'call' && expr.callee.kind === 'identifier' && expr.args.length === 0) {
-    return isStringName(expr.callee.name)
-  }
-  if (expr.kind === 'member' && expr.object.kind === 'identifier' && expr.object.name === 'props') {
-    return isStringName(expr.property)
-  }
-  return false
-}
+import { isStringTypedOperand, type ParsedExpr } from '@barefootjs/jsx'
 
 /**
  * Lower `arr[index]` to a Perl deref. Perl distinguishes array

package/src/adapter/lib/constants.ts

@@ -26,6 +26,9 @@ export const MOJO_TEMPLATE_PRIMITIVES: Record<string, PrimitiveSpec> = {
   'Math.floor':     { arity: 1, emit: (args) => `bf->floor(${args[0]})` },
   'Math.ceil':      { arity: 1, emit: (args) => `bf->ceil(${args[0]})` },
   'Math.round':     { arity: 1, emit: (args) => `bf->round(${args[0]})` },
+  'Math.min':       { arity: 2, emit: (args) => `bf->min(${args[0]}, ${args[1]})` },
+  'Math.max':       { arity: 2, emit: (args) => `bf->max(${args[0]}, ${args[1]})` },
+  'Math.abs':       { arity: 1, emit: (args) => `bf->abs(${args[0]})` },
 }
 
 /**

package/src/adapter/mojo-adapter.ts

@@ -62,7 +62,7 @@ import {
 } from '@barefootjs/jsx'
 import { isAriaBooleanAttr, isBooleanResultExpr } from './boolean-result.ts'
 import type { ParsedExpr, LoweringMatcher } from '@barefootjs/jsx'
-import { BF_SLOT, BF_COND, BF_REGION } from '@barefootjs/shared'
+import { BF_SLOT, BF_COND, BF_REGION, escapeHtml } from '@barefootjs/shared'
 
 import type { MojoRenderCtx } from './lib/types.ts'
 import { MOJO_PRIMITIVE_EMIT_MAP } from './lib/constants.ts'
@@ -165,6 +165,14 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
   private options: Required<MojoAdapterOptions>
   private errors: CompilerError[] = []
   private inLoop: boolean = false
+  /**
+   * `IRLoop.depth` of the loop currently being rendered (save/restore
+   * around `renderChildren(loop.children)`, mirroring `inLoop` above).
+   * `renderAttributes` reads this to derive the `key` → `data-key`/
+   * `data-key-N` suffix — the depth is IR-computed (jsx-to-ir.ts), not
+   * re-derived here (#2168 nested-loop-outer-binding).
+   */
+  private currentLoopKeyDepth = 0
   /**
    * SolidJS-style props identifier (`function(props: P)`) and the
    * analyzer-extracted prop names. Stashed at `generate()` entry so
@@ -478,7 +486,9 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
   }
 
   emitText(node: IRText): string {
-    return node.value
+    // IRText carries the entity-DECODED value (Phase 1 decodes JSX
+    // character references); re-escape for direct HTML emission.
+    return escapeHtml(node.value)
   }
 
   emitExpression(node: IRExpression): string {
@@ -846,17 +856,22 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
     // the whole body (children + key + filter) so a same-named loop variable
     // isn't replaced by the const literal (#1749 review). Ref-counted for
     // nested loops; released after the body lines are assembled below.
-    const loopBound = loop.iterationShape === 'keys'
-      ? [param]
-      : supportableDestructure
-        ? ['__bf_item', ...(loop.paramBindings ?? []).map(b => b.name), loop.index ?? '_i']
-        : [param, loop.index ?? '_i']
+    const loopBound = loop.objectIteration === 'entries'
+      ? [param, loop.index ?? '_k']
+      : loop.objectIteration === 'keys' || loop.objectIteration === 'values' || loop.iterationShape === 'keys'
+        ? [param]
+        : supportableDestructure
+          ? ['__bf_item', ...(loop.paramBindings ?? []).map(b => b.name), loop.index ?? '_i']
+          : [param, loop.index ?? '_i']
     for (const n of loopBound) {
       this.loopBoundNames.set(n, (this.loopBoundNames.get(n) ?? 0) + 1)
     }
     const prevInLoop = this.inLoop
     this.inLoop = true
+    const prevLoopKeyDepth = this.currentLoopKeyDepth
+    this.currentLoopKeyDepth = loop.depth
     const renderedChildren = this.renderChildren(loop.children)
+    this.currentLoopKeyDepth = prevLoopKeyDepth
     this.inLoop = prevInLoop
 
     // Whole-item conditional (#1665): prepend an always-present
@@ -918,6 +933,21 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
       }
       lines.push(`% my $${sortedHoist} = ${sorted};`)
     }
+    if (loop.objectIteration) {
+      // `objectIteration` (#2168 object-entries-map): a Perl hash has no
+      // native insertion-order guarantee (unlike Ruby's `Hash`/Python's
+      // `dict`) — this codebase's own runtime already works around this
+      // elsewhere with `sort keys %$hash` (`BarefootJS.pm`'s
+      // `spread_attrs`/`_style_to_css`), so this reuses that exact
+      // convention for a deterministic, alphabetically-sorted iteration
+      // (not JS insertion order — a documented known limitation for
+      // out-of-alphabetical-order data, same as Go/Rust/Xslate).
+      const keyVar = loop.objectIteration === 'values' ? '$__bf_k' : `$${loop.index ?? param}`
+      lines.push(`% for my ${keyVar} (sort keys %{${array}}) {`)
+      if (loop.objectIteration === 'entries' || loop.objectIteration === 'values') {
+        lines.push(`% my $${param} = ${array}->{${keyVar}};`)
+      }
+    } else {
     lines.push(`% for my ${indexVar} (0..$#{${array}}) {`)
     if (loop.iterationShape !== 'keys') {
       if (supportableDestructure) {
@@ -951,6 +981,7 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
         lines.push(`% my $${param} = ${array}->[${indexVar}];`)
       }
     }
+    }
 
     // Handle filter().map() pattern by wrapping children in if-condition
     if (loop.filterPredicate) {
@@ -1049,10 +1080,36 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
 
   renderComponent(comp: IRComponent): string {
     const propParts: string[] = []
+    // Named JSX-valued props OTHER than the reserved `children`
+    // (`header={<strong>Title</strong>}`, #2168 jsx-element-prop) get the
+    // same `begin %>…<% end` capture as the reserved children slot below,
+    // just keyed by the prop's own name. `render_child` (BarefootJS.pm)
+    // materializes every prop value that's a CODE ref — not only
+    // `children` — into the Mojo::ByteStream the capture block produces,
+    // so the child's read of the slot back out (`<%= $header %>`) sees an
+    // already-safe ByteStream and Mojo::Template's auto-escape passes it
+    // through unescaped, the same way it already does for `children`.
+    const namedSlotCaptures: string[] = []
     for (const p of comp.props) {
       // Skip callback props (onXxx) and `ref` — both are client-only for
       // SSR (Hono renders neither; the client JS wires them at hydration).
       if ((p.name.match(/^on[A-Z]/) || p.name === 'ref') && p.value.kind === 'expression') continue
+      if (p.value.kind === 'jsx-children' && p.name !== 'children') {
+        const prevInLoop = this.inLoop
+        this.inLoop = false
+        const slotBody = this.renderChildren(p.value.children)
+        this.inLoop = prevInLoop
+        // Purely counter-based — NOT derived from `p.name` or `comp.slotId`.
+        // A JSX prop name can contain characters (`data-slot`) that aren't a
+        // valid Perl variable token, and `comp.slotId` alone would collide
+        // across two named-slot props on the same component invocation
+        // (unlike the reserved children slot, there's only ever one of
+        // those per invocation).
+        const varName = `$bf_prop_${this.childrenCaptureCounter++}`
+        namedSlotCaptures.push(`<% my ${varName} = begin %>${slotBody}<% end %>`)
+        propParts.push(`${perlHashKey(p.name)} => ${varName}`)
+        continue
+      }
       const lowered = emitAttrValue(p.value, this.componentPropEmitter, p.name)
       if (lowered) propParts.push(lowered)
     }
@@ -1090,9 +1147,9 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
       const childrenBody = this.renderChildren(effectiveChildren)
       this.inLoop = prevInLoop
       const varName = `$bf_children_${comp.slotId ?? 'c' + this.childrenCaptureCounter++}`
-      return `<% my ${varName} = begin %>${childrenBody}<% end %><%== bf->render_child('${tplName}'${propsStr}, children => ${varName}) %>`
+      return `${namedSlotCaptures.join('')}<% my ${varName} = begin %>${childrenBody}<% end %><%== bf->render_child('${tplName}'${propsStr}, children => ${varName}) %>`
     }
-    return `<%== bf->render_child('${tplName}'${propsStr}) %>`
+    return `${namedSlotCaptures.join('')}<%== bf->render_child('${tplName}'${propsStr}) %>`
   }
 
   private childrenCaptureCounter = 0
@@ -1178,7 +1235,7 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
    * template). Routed through the shared dispatcher (#1290 step 2).
    */
   private readonly elementAttrEmitter: AttrValueEmitter = {
-    emitLiteral: (value, name) => `${name}="${value.value}"`,
+    emitLiteral: (value, name) => `${name}="${escapeHtml(value.value)}"`,
     emitExpression: (value, name) => {
       // `style={{ … }}` object literal → a CSS string with dynamic values
       // interpolated, instead of refusing the bare object with BF101 (#1322).
@@ -1440,7 +1497,10 @@ export class MojoAdapter extends BaseAdapter implements IRNodeEmitter<MojoRender
       // rewrite happens at attribute-emit time.
       let attrName: string
       if (attr.name === 'className') attrName = 'class'
-      else if (attr.name === 'key') attrName = 'data-key'
+      else if (attr.name === 'key') {
+        const depth = this.currentLoopKeyDepth
+        attrName = depth > 0 ? `data-key-${depth}` : 'data-key'
+      }
       else attrName = attr.name
       const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, attrName)
       if (lowered) parts.push(lowered)

package/src/conformance-pins.ts

@@ -141,9 +141,4 @@ export const conformancePins: ConformancePins = {
   // the shape loudly instead of emitting entity-escaped markup that
   // silently renders tags as text.
   'dangerous-inner-html': [{ code: 'BF101', severity: 'error' }],
-  // Edge-case sweep (Priority 12): `.replaceAll` has no lowering yet —
-  // only first-occurrence `.replace` is wired to the runtime helpers.
-  // Refused with BF101 rather than reusing the first-only lowering,
-  // which would silently change semantics.
-  'string-replaceall': [{ code: 'BF101', severity: 'error' }],
 }

package/src/render-divergences.ts

@@ -14,35 +14,4 @@
 
 import type { RenderDivergences } from '@barefootjs/jsx'
 
-export const renderDivergences: RenderDivergences = {
-  'arithmetic-text':
-    '`(count() + 2) * 3` renders 10 instead of 18 — the parenthesised sub-expression loses its grouping (silent wrong arithmetic)',
-  'string-concat-plus':
-    "`'Hello, ' + name` renders \"0\" — Perl's numeric `+` coerces the strings; JS string-concat `+` needs Perl's `.`",
-  'string-length-text':
-    '`.length` on a STRING prop diverges (array-length lowering misapplied to a scalar)',
-  'number-tofixed':
-    'the literal `¥` in template text reaches the output as U+FFFD — a UTF-8 encoding gap for non-ASCII literal text adjacent to a dynamic slot',
-  'html-entity-text':
-    '`©` in JSX literal text: Hono decodes to `©`, this adapter re-emits the raw entity — same DOM, different bytes',
-  'math-methods':
-    'Math.min/max/abs over a signal render empty (only Math.floor is in the template-primitive registry)',
-  'boolean-attr-literals':
-    'camelCase boolean alias `readOnly`: Hono SSRs `readOnly="true"`, this adapter emits bare presence',
-  'camelcase-attributes':
-    '`htmlFor` is not lowered to `for` (Hono maps it)',
-  'static-attr-escape':
-    'static attribute values are not HTML-escaped (`title="Fish & Chips"` emitted raw; Hono escapes)',
-  'svg-icon':
-    'SVG camelCase presentation attrs (`strokeWidth`, `strokeLinecap`) pass through unmapped; Hono lowers to kebab-case',
-  'object-entries-map':
-    '`Object.entries(prop).map(([k, v]) => …)` renders an EMPTY list — the object-shaped prop silently produces zero iterations',
-  'nested-loop-outer-binding':
-    'nested-loop inner items carry `data-key` where the reference emits the depth-suffixed `data-key-1`',
-  'jsx-element-prop':
-    'a JSX element passed as a NON-children prop renders an empty slot — the element value is silently dropped',
-  'string-slice':
-    '`.slice()` on a STRING misfires through the array slice helper',
-  'string-trim-sided':
-    '`.trimStart()` / `.trimEnd()` render empty (no lowering)',
-}
+export const renderDivergences: RenderDivergences = {}

package/src/test-render.ts

@@ -240,6 +240,11 @@ export async function renderMojoComponent(options: RenderOptions): Promise<strin
 use strict;
 use warnings;
 use utf8;
+# The template is read through :utf8, so $output holds decoded wide
+# characters; without a matching layer on STDOUT Perl emits them as
+# latin-1 bytes and the harness reads U+FFFD (©/¥ mangling). A real
+# Mojolicious response encodes on the way out — this is harness-only.
+binmode STDOUT, ':encoding(UTF-8)';
 
 use lib '${LIB_DIR}', '${PERL_CORE_LIB_DIR}';
 use Mojolicious;