@barefootjs/mojolicious 0.7.0 → 0.9.0

package/dist/index.js

@@ -8,7 +8,10 @@ import {
   identifierPath,
   emitParsedExpr,
   emitIRNode,
-  emitAttrValue
+  emitAttrValue,
+  augmentInheritedPropAccesses,
+  parseRecordIndexAccess,
+  evalStringArrayJoin
 } from "@barefootjs/jsx";
 
 // src/adapter/boolean-result.ts
@@ -95,7 +98,10 @@ function parsePureStringLiteral(source) {
   if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) {
     return init.text;
   }
-  return null;
+  return evalStringArrayJoin(source);
+}
+function perlHashKey(name) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : `'${name.replace(/'/g, "\\'")}'`;
 }
 
 class MojoAdapter extends BaseAdapter {
@@ -112,7 +118,9 @@ class MojoAdapter extends BaseAdapter {
   propsParams = [];
   stringValueNames = new Set;
   moduleStringConsts = new Map;
+  localConstants = [];
   loopBoundNames = new Map;
+  nullableOptionalProps = new Set;
   constructor(options = {}) {
     super();
     this.options = {
@@ -123,7 +131,9 @@ class MojoAdapter extends BaseAdapter {
   generate(ir, options) {
     this.componentName = ir.metadata.componentName;
     this.propsObjectName = ir.metadata.propsObjectName ?? null;
+    augmentInheritedPropAccesses(ir);
     this.propsParams = ir.metadata.propsParams.map((p) => ({ name: p.name }));
+    this.nullableOptionalProps = new Set(ir.metadata.propsParams.filter((p) => p.defaultValue === undefined && !p.isRest && p.type?.kind !== "primitive").map((p) => p.name));
     this.stringValueNames = new Set;
     for (const s of ir.metadata.signals) {
       if (isStringTypeInfo(s.type) || isBareStringLiteral(s.initialValue)) {
@@ -135,6 +145,7 @@ class MojoAdapter extends BaseAdapter {
         this.stringValueNames.add(p.name);
     }
     this.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants);
+    this.localConstants = ir.metadata.localConstants ?? [];
     this.loopBoundNames.clear();
     this.errors = [];
     this.childrenCaptureCounter = 0;
@@ -497,20 +508,20 @@ ${renderedChildren}` : renderedChildren;
 `);
   }
   componentPropEmitter = {
-    emitLiteral: (value, name) => `${name} => '${value.value}'`,
+    emitLiteral: (value, name) => `${perlHashKey(name)} => '${value.value}'`,
     emitExpression: (value, name) => {
       if (value.parts) {
-        return `${name} => ${this.convertTemplateLiteralPartsToPerl(value.parts)}`;
+        return `${perlHashKey(name)} => ${this.convertTemplateLiteralPartsToPerl(value.parts)}`;
       }
-      return `${name} => ${this.convertExpressionToPerl(value.expr)}`;
+      return `${perlHashKey(name)} => ${this.convertExpressionToPerl(value.expr)}`;
     },
     emitSpread: (value) => {
       const perlExpr = this.convertExpressionToPerl(value.expr);
       return perlExpr.startsWith("%") ? perlExpr : `%{${perlExpr}}`;
     },
-    emitTemplate: (value, name) => `${name} => ${this.convertTemplateLiteralPartsToPerl(value.parts)}`,
-    emitBooleanAttr: (_value, name) => `${name} => 1`,
-    emitBooleanShorthand: (_value, name) => `${name} => 1`,
+    emitTemplate: (value, name) => `${perlHashKey(name)} => ${this.convertTemplateLiteralPartsToPerl(value.parts)}`,
+    emitBooleanAttr: (_value, name) => `${perlHashKey(name)} => 1`,
+    emitBooleanShorthand: (_value, name) => `${perlHashKey(name)} => 1`,
     emitJsxChildren: () => ""
   };
   renderComponent(comp) {
@@ -582,6 +593,13 @@ ${children}`;
       if (this.refuseUnsupportedAttrExpression(value.expr, name)) {
         return "";
       }
+      const bareId = value.expr.trim();
+      const normalizedBareId = this.propsObjectName && bareId.startsWith(`${this.propsObjectName}.`) ? bareId.slice(this.propsObjectName.length + 1) : bareId;
+      if (!isBooleanAttr(name) && !value.presenceOrUndefined && /^[A-Za-z_$][\w$]*$/.test(normalizedBareId) && this.nullableOptionalProps.has(normalizedBareId)) {
+        const perl2 = this.convertExpressionToPerl(value.expr);
+        const body = isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name) ? `${name}="<%= bf->bool_str(${perl2}) %>"` : `${name}="<%= ${perl2} %>"`;
+        return `<% if (defined ${perl2}) { %>${body}<% } %>`;
+      }
       if (isBooleanAttr(name) || value.presenceOrUndefined) {
         return `<%= ${this.convertExpressionToPerl(value.expr)} ? '${name}' : '' %>`;
       }
@@ -602,6 +620,22 @@ ${children}`;
         const entries = this.propsParams.map((p) => `${JSON.stringify(p.name)} => $${p.name}`);
         return `<%== bf->spread_attrs({${entries.join(", ")}}) %>`;
       }
+      const ternaryHashref = this.conditionalSpreadToPerl(trimmed);
+      if (ternaryHashref !== null) {
+        return `<%== bf->spread_attrs(${ternaryHashref}) %>`;
+      }
+      if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(trimmed)) {
+        const localConst = this.localConstants.find((c) => c.name === trimmed && !c.isModule);
+        if (localConst?.value !== undefined) {
+          const initTrimmed = localConst.value.trim();
+          if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(initTrimmed)) {
+            const resolved = this.conditionalSpreadToPerl(initTrimmed);
+            if (resolved !== null) {
+              return `<%== bf->spread_attrs(${resolved}) %>`;
+            }
+          }
+        }
+      }
       const perlExpr = this.convertExpressionToPerl(value.expr);
       return `<%== bf->spread_attrs(${perlExpr}) %>`;
     },
@@ -766,6 +800,71 @@ ${reason}` : "";
     });
     return true;
   }
+  conditionalSpreadToPerl(expr) {
+    const sf = ts.createSourceFile("__spread.ts", `(${expr})`, ts.ScriptTarget.Latest, true);
+    if (sf.statements.length !== 1)
+      return null;
+    const stmt = sf.statements[0];
+    if (!ts.isExpressionStatement(stmt))
+      return null;
+    let node = stmt.expression;
+    while (ts.isParenthesizedExpression(node))
+      node = node.expression;
+    if (!ts.isConditionalExpression(node))
+      return null;
+    const unwrap = (e) => {
+      let n = e;
+      while (ts.isParenthesizedExpression(n))
+        n = n.expression;
+      return n;
+    };
+    const whenTrue = unwrap(node.whenTrue);
+    const whenFalse = unwrap(node.whenFalse);
+    if (!ts.isObjectLiteralExpression(whenTrue) || !ts.isObjectLiteralExpression(whenFalse)) {
+      return null;
+    }
+    const condPerl = this.convertExpressionToPerl(node.condition.getText(sf));
+    const truePerl = this.objectLiteralToPerlHashref(whenTrue, sf);
+    const falsePerl = this.objectLiteralToPerlHashref(whenFalse, sf);
+    if (truePerl === null || falsePerl === null)
+      return null;
+    return `${condPerl} ? ${truePerl} : ${falsePerl}`;
+  }
+  objectLiteralToPerlHashref(obj, sf) {
+    const entries = [];
+    for (const prop of obj.properties) {
+      if (!ts.isPropertyAssignment(prop))
+        return null;
+      let key;
+      if (ts.isIdentifier(prop.name)) {
+        key = prop.name.text;
+      } else if (ts.isStringLiteral(prop.name) || ts.isNoSubstitutionTemplateLiteral(prop.name)) {
+        key = prop.name.text;
+      } else {
+        return null;
+      }
+      const initNode = (() => {
+        let n = prop.initializer;
+        while (ts.isParenthesizedExpression(n))
+          n = n.expression;
+        return n;
+      })();
+      const indexed = this.recordIndexAccessToPerl(initNode);
+      const valPerl = indexed !== null ? indexed : this.convertExpressionToPerl(prop.initializer.getText(sf));
+      entries.push(`'${key.replace(/'/g, "\\'")}' => ${valPerl}`);
+    }
+    return entries.length === 0 ? "{}" : `{ ${entries.join(", ")} }`;
+  }
+  recordIndexAccessToPerl(val) {
+    const parsed = parseRecordIndexAccess(val, this.localConstants, this.propsParams);
+    if (!parsed)
+      return null;
+    const entries = parsed.entries.map((e) => {
+      const mapVal = e.value.kind === "number" ? e.value.text : `'${e.value.text.replace(/'/g, "\\'")}'`;
+      return `'${e.key.replace(/'/g, "\\'")}' => ${mapVal}`;
+    });
+    return `{ ${entries.join(", ")} }->{$${parsed.indexPropName}}`;
+  }
   convertExpressionToPerl(expr) {
     const trimmed = expr.trim();
     if (trimmed === "")

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

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

package/lib/BarefootJS/Backend/Mojo.pm

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

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

@@ -1,5 +1,5 @@
 package Mojolicious::Plugin::BarefootJS::DevReload;
-our $VERSION = "0.01";
+our $VERSION = "0.8.0";
 use Mojo::Base 'Mojolicious::Plugin', -signatures;
 
 =head1 NAME
@@ -30,21 +30,12 @@ C<< enabled => 1 >> to force-enable.
 use Mojo::ByteStream qw(b);
 use Mojo::IOLoop;
 use File::Spec;
+use BarefootJS::DevReload ();
 
-# Sentinel path contract with @barefootjs/cli (DEV_SENTINEL_SUBDIR /
-# DEV_SENTINEL_FILENAME in packages/cli/src/lib/build.ts). Duplicated so this
-# package avoids a runtime dep on the CLI — keep in sync with the CLI.
-my $DEV_SUBDIR         = '.dev';
-my $BUILD_ID_FILE      = 'build-id';
-my $SCROLL_STORAGE_KEY = '__bf_devreload_scroll';
-
-# Heartbeat < any reasonable proxy/IOLoop idle timeout so a quiet connection
-# doesn't get reaped between rebuilds.
-my $HEARTBEAT_S = 5;
-
-# Polling instead of Linux::Inotify2 / Mac::FSEvents keeps the runtime
-# dependency-free. Sub-second latency is imperceptible next to browser reload.
-my $POLL_S = 0.5;
+# Engine-agnostic snippet, build-id reading, and timing constants are shared
+# with the PSGI/Plack path in BarefootJS::DevReload — one source of truth.
+my $HEARTBEAT_S = $BarefootJS::DevReload::HEARTBEAT_S;
+my $POLL_S      = $BarefootJS::DevReload::POLL_S;
 
 sub register ($self, $app, $config = {}) {
     my $dist_dir = $config->{dist_dir} // 'dist';
@@ -57,7 +48,7 @@ sub register ($self, $app, $config = {}) {
     # on mode — it simply returns an empty ByteStream when disabled.
     $app->helper(bf_dev_snippet => sub ($c) {
         return b('') unless $enabled;
-        return b(_snippet($endpoint));
+        return b(BarefootJS::DevReload->snippet($endpoint));
     });
 
     return unless $enabled;
@@ -68,9 +59,8 @@ sub register ($self, $app, $config = {}) {
     my $dist_abs = File::Spec->file_name_is_absolute($dist_dir)
         ? $dist_dir
         : $app->home->child($dist_dir)->to_string;
-    my $dev_dir       = File::Spec->catdir($dist_abs, $DEV_SUBDIR);
-    my $build_id_path = File::Spec->catfile($dev_dir, $BUILD_ID_FILE);
-    mkdir $dev_dir unless -d $dev_dir;
+    BarefootJS::DevReload->ensure_dev_dir($dist_abs);
+    my $build_id_path = BarefootJS::DevReload->build_id_path($dist_abs);
 
     $app->routes->get($endpoint => sub ($c) {
         my $last_event_id = $c->req->headers->header('Last-Event-ID') // '';
@@ -83,7 +73,7 @@ sub register ($self, $app, $config = {}) {
 
         $c->write("retry: 1000\n\n");
 
-        my $initial_id = _read_build_id($build_id_path);
+        my $initial_id = BarefootJS::DevReload->read_build_id($build_id_path);
         my $last_sent  = '';
         if (length $initial_id) {
             $last_sent = $initial_id;
@@ -106,7 +96,7 @@ sub register ($self, $app, $config = {}) {
             $c->write(": hb\n\n");
         });
         $poll_id = Mojo::IOLoop->recurring($POLL_S => sub {
-            my $id = _read_build_id($build_id_path);
+            my $id = BarefootJS::DevReload->read_build_id($build_id_path);
             return unless length $id;
             return if $id eq $last_sent;
             $last_sent = $id;
@@ -117,35 +107,4 @@ sub register ($self, $app, $config = {}) {
     return;
 }
 
-sub _read_build_id ($path) {
-    return '' unless -f $path;
-    open my $fh, '<', $path or return '';
-    local $/;
-    my $content = <$fh>;
-    close $fh;
-    $content //= '';
-    $content =~ s/^\s+|\s+$//g;
-    return $content;
-}
-
-sub _snippet ($endpoint) {
-    my $ep = _js_str($endpoint);
-    my $sk = _js_str($SCROLL_STORAGE_KEY);
-    # Small IIFE: EventSource subscriber + scrollY preservation. Idempotent
-    # across duplicate mounts (window.__bfDevReload guard).
-    return qq{<script>(function(){if(window.__bfDevReload)return;window.__bfDevReload=1;try{var s=sessionStorage.getItem($sk);if(s){sessionStorage.removeItem($sk);var y=parseInt(s,10);if(!isNaN(y)){var restore=function(){window.scrollTo(0,y)};if(document.readyState==='loading'){addEventListener('DOMContentLoaded',restore,{once:true})}else{restore()}}}}catch(e){}var es=new EventSource($ep);es.addEventListener('reload',function(){try{sessionStorage.setItem($sk,String(window.scrollY))}catch(e){}location.reload()});es.addEventListener('error',function(){})})();</script>};
-}
-
-sub _js_str ($s) {
-    # Minimal JS string escape for the handful of characters that can appear
-    # in a URL path or storage key. Good enough for package-internal + trusted
-    # operator-supplied strings; never interpolate untrusted input here.
-    my $t = $s;
-    $t =~ s/\\/\\\\/g;
-    $t =~ s/"/\\"/g;
-    $t =~ s/\n/\\n/g;
-    $t =~ s/\r/\\r/g;
-    return qq{"$t"};
-}
-
 1;

package/lib/Mojolicious/Plugin/BarefootJS.pm

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

package/package.json

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

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

@@ -17,69 +17,19 @@ runAdapterConformanceTests({
   name: 'mojo',
   factory: () => new MojoAdapter(),
   render: renderMojoComponent,
-  // Dynamic style objects (non-static values) require Perl template
-  // interpolation support for JS object literals, not yet implemented.
-  // Mojo currently emits invalid Perl silently for this shape — the
-  // Go adapter records BF101 via `convertExpressionToGo()` for the
-  // same fixture (now contracted via `expectedDiagnostics`), but the
-  // Mojo adapter's expression gate doesn't yet lift the same
-  // failure into a `CompilerError`, so the fixture stays on `skipJsx`
-  // until that gate is extended (#1266 follow-up).
-  // `logical-or-jsx`, `nullish-coalescing-jsx`, `branch-map` reference
-  // a prop directly inside a conditional branch (`$label`, `$banner`,
-  // `$active`). The Mojo adapter emits these as bare Perl variables
-  // (`% if ($label) { ... }`) without a corresponding
-  // `my $label = ...;` declaration, so Perl rejects the template with
-  // "Global symbol requires explicit package name". Same class of
-  // Perl-scoping divergence that motivates the existing skips —
-  // out of scope for the #971 refactor.
-  // Return-position variants of the same divergence —
-  // `return-logical-or` / `return-nullish-coalescing` reference
-  // `$label` / `$banner` directly; `return-map` iterates over `$items`
-  // without a `my` declaration.
-  //
-  // `static-array-children` / `static-array-from-props` /
-  // `static-array-from-props-with-component` are no longer here —
-  // they're covered by `expectedDiagnostics` below, asserting that
-  // the adapter emits `BF103` / `BF104` at build time instead of
-  // silently emitting invalid Perl / unresolved cross-template
-  // references (#1266).
   skipJsx: [
-    'style-object-dynamic',
-    'logical-or-jsx',
-    'nullish-coalescing-jsx',
-    'branch-map',
-    'return-logical-or',
-    'return-nullish-coalescing',
-    'return-map',
-    // #1297 fixed the harness-side IR emission gate. The remaining
-    // gap is adapter-side: the Mojo adapter has no SSR context-
-    // propagation mechanism, so `<Ctx.Provider value="dark">` doesn't
-    // make `useContext(Ctx)` resolve to `"dark"` at template-eval
-    // time — the template emits `<%= $theme %>` against a hash that
-    // never receives a `theme` key. Provider SSR coverage on Mojo
-    // waits on that adapter feature; see #1297 follow-up.
+    // SSR context propagation (`<Ctx.Provider value>` → `useContext`): the
+    // template reads a stash key that's never seeded. Implemented on Go; the
+    // Perl stash-seed path is a follow-up port, so Mojo stays skipped (#1297).
     'context-provider',
-    // Multi-component fixtures still diverge because Mojo's child
-    // template emitter pins the child's `bf-s` to the literal
-    // `test_<sN>` (`_scope_id("test_$sid")` in `test-render.ts`)
-    // instead of `<ChildName>_<id>_<sN>` like Hono / CSR. Same family
-    // of test-harness scope-id plumbing the `componentName` option
-    // fixed on the Hono side. Separate follow-up.
+    // Multi-component shared fixtures with per-item loop state. The child
+    // scope-id plumbing is now fixed (children derive `<parentScope>_<sN>`
+    // from `$bf->_scope_id` in `test-render.ts`, which unblocked
+    // `reactive-props`); these two still diverge on additional per-item
+    // loop-state seeding the Mojo harness doesn't yet replicate. (xslate
+    // skips the same pair.)
     'toggle-shared',
-    'reactive-props',
     'props-reactivity-comparison',
-    // #1467 Phase 2b: basic interactive `site/ui` primitives. Cross-adapter
-    // parity for the `site/ui` corpus is Phase 3, so these participate only
-    // in Hono SSR conformance + the fixture-hydrate runtime layer for now.
-    // (`label` and `kbd` are static helpers; `toggle` / `switch` /
-    // `checkbox` carry uncontrolled state; `input` / `textarea` are
-    // pass-through native controls.)
-    'toggle',
-    'switch',
-    'checkbox',
-    'textarea',
-    'kbd',
   ],
   // Per-fixture build-time contracts for shapes the Mojo adapter
   // intentionally refuses to lower. Owned by this adapter test file
@@ -123,6 +73,11 @@ runAdapterConformanceTests({
     // surfaces BF101 with a wrap-in-`/* @client */` suggestion, matching
     // the Go adapter's behaviour.
     'style-3-signals': [{ code: 'BF101', severity: 'error' }],
+    // Dynamic JS object literal in `style={{ … }}` — same no-EP-form
+    // refusal as `style-3-signals`; `refuseUnsupportedAttrExpression`
+    // surfaces BF101 (mirrors the xslate + Go adapters). Was a stale
+    // `skipJsx` entry claiming the gate didn't lift to a CompilerError.
+    'style-object-dynamic': [{ code: 'BF101', severity: 'error' }],
     // #1244 stress catalog #12 (#1323): tagged-template-literal call
     // (`cn\`base \${tone()}\``) — same family as #1322 above and refused
     // via the same gate.
@@ -240,6 +195,190 @@ function compileAndGenerate(source: string, adapter?: MojoAdapter) {
 // Mojo-Specific Tests
 // =============================================================================
 
+describe('MojoAdapter - conditional inline-object spread (textarea aria-describedby)', () => {
+  // `{...(cond ? { 'aria-describedby': cond } : {})}` lowers to a Perl
+  // inline ternary of hashrefs so the falsy `{}` branch OMITS the key
+  // (bf->spread_attrs does not filter empty strings). The shared
+  // fixture only exercises the falsy branch; this pins the truthy one.
+  test('emits a Perl inline ternary of hashrefs through bf->spread_attrs', () => {
+    const { template } = compileAndGenerate(`
+function Box({ describedBy }: { describedBy?: string }) {
+  return <div {...(describedBy ? { 'aria-describedby': describedBy } : {})} />
+}
+`)
+    expect(template).toContain(
+      "bf->spread_attrs($describedBy ? { 'aria-describedby' => $describedBy } : {})",
+    )
+  })
+
+  test('resolves the value reference and preserves the static key for a second prop', () => {
+    const { template } = compileAndGenerate(`
+function Box({ label }: { label: string }) {
+  return <div {...(label ? { 'data-label': label } : {})} />
+}
+`)
+    expect(template).toContain(
+      "bf->spread_attrs($label ? { 'data-label' => $label } : {})",
+    )
+  })
+
+  test('falls back to BF101 for a computed (non-static) object key', () => {
+    const adapter = new MojoAdapter()
+    const ir = compileToIR(`
+function Box({ k, v }: { k?: string; v?: string }) {
+  return <div {...(v ? { [k]: v } : {})} />
+}
+`, adapter)
+    adapter.generate(ir)
+    const errs = (adapter as unknown as { errors: { code: string }[] }).errors
+    expect(errs.some(e => e.code === 'BF101')).toBe(true)
+  })
+})
+
+describe('MojoAdapter - local-const conditional-spread resolution (#checkbox icon)', () => {
+  // A FUNCTION-scope const holding a `cond ? {…} : {}` ternary, spread as
+  // a bare identifier (`{...attrs}`), resolves through the same Perl
+  // ternary-of-hashrefs lowering as the inline form. CheckIcon's
+  // `const sizeAttrs = size ? {…} : {}` is exactly this shape.
+  test('resolves a bare-identifier spread of a function-scope conditional const', () => {
+    const { template } = compileAndGenerate(`
+function Box({ flag }: { flag?: boolean }) {
+  const attrs = flag ? { 'data-on': 'yes' } : {}
+  return <div {...attrs} />
+}
+`)
+    expect(template).toContain(
+      "bf->spread_attrs($flag ? { 'data-on' => 'yes' } : {})",
+    )
+  })
+
+  // A const that aliases another bare identifier must NOT be forwarded
+  // (loop guard): the resolver bails, so the spread falls through to the
+  // standard `convertExpressionToPerl` path emitting the bare `$attrs`
+  // variable rather than recursively resolving the alias into a hashref.
+  test('does not forward a const that aliases another identifier (loop guard)', () => {
+    const { template } = compileAndGenerate(`
+function Box({ other }: { other?: object }) {
+  const attrs = other
+  return <div {...attrs} />
+}
+`)
+    expect(template).toContain('bf->spread_attrs($attrs)')
+  })
+})
+
+describe('MojoAdapter - Record<staticKeys,scalar>[propKey] spread value (#checkbox icon)', () => {
+  // `const sizeMap: Record<IconSize, number> = { sm: 16, ... }` indexed by
+  // a prop inside a conditional-spread object value lowers to an inline
+  // indexed Perl hashref `{ ... }->{$key}`. This is CheckIcon's
+  // `{ width: sizeMap[size], height: sizeMap[size] }` shape.
+  test('lowers an indexed module-const map to an inline hashref index', () => {
+    const { template } = compileAndGenerate(`
+const sizeMap: Record<string, number> = { sm: 16, md: 20, lg: 24, xl: 32 }
+function Box({ size }: { size?: string }) {
+  const attrs = size ? { width: sizeMap[size] } : {}
+  return <div {...attrs} />
+}
+`)
+    expect(template).toContain(
+      "{ 'sm' => 16, 'md' => 20, 'lg' => 24, 'xl' => 32 }->{$size}",
+    )
+  })
+
+  test('lowers string-valued record maps too', () => {
+    const { template } = compileAndGenerate(`
+const labelMap: Record<string, string> = { a: 'Alpha', b: 'Beta' }
+function Box({ k }: { k?: string }) {
+  const attrs = k ? { 'data-label': labelMap[k] } : {}
+  return <div {...attrs} />
+}
+`)
+    expect(template).toContain("{ 'a' => 'Alpha', 'b' => 'Beta' }->{$k}")
+  })
+
+  // A non-scalar record value (object) is out of shape: the spread object
+  // value can't lower, so the whole spread falls back to BF101.
+  test('refuses a non-scalar record value with BF101 (out-of-shape fallback)', () => {
+    const adapter = new MojoAdapter()
+    const ir = compileToIR(`
+const sizeMap: Record<string, object> = { sm: { w: 1 } }
+function Box({ size }: { size?: string }) {
+  const attrs = size ? { width: sizeMap[size] } : {}
+  return <div {...attrs} />
+}
+`, adapter)
+    adapter.generate(ir)
+    const errs = (adapter as unknown as { errors: { code: string }[] }).errors
+    expect(errs.some(e => e.code === 'BF101')).toBe(true)
+  })
+})
+
+describe('MojoAdapter - props-object inherited-attribute enumeration (#checkbox)', () => {
+  // A SolidJS props-object component reads inherited attributes (`props.id`)
+  // not enumerated in `propsParams`. The bare optional attribute must be
+  // guarded with Perl `defined` so it's omitted when unset (Hono parity),
+  // even though `id` isn't a declared param.
+  test('guards a props-object bare optional attr (props.id) with defined', () => {
+    const { template } = compileAndGenerate(`
+"use client"
+interface P { tone?: string }
+export function Widget(props: P) {
+  return <button id={props.id}>x</button>
+}
+`)
+    expect(template).toContain('<% if (defined $id) { %>id="<%= $id %>"<% } %>')
+  })
+})
+
+describe('MojoAdapter - hyphenated child attr hash key (#checkbox)', () => {
+  // A child component prop whose JSX name isn't a bare Perl identifier
+  // (`<CheckIcon data-slot="..."/>`) must be quoted in the `render_child`
+  // named-arg list — an unquoted `data-slot => ...` parses as `data - slot`.
+  test('quotes a hyphenated child attribute name in render_child', () => {
+    const { template } = compileAndGenerate(`
+"use client"
+import { Leaf } from './leaf'
+export function Host() {
+  return <div><Leaf data-slot="indicator" size="sm" /></div>
+}
+`)
+    expect(template).toContain("'data-slot' => 'indicator'")
+    // A bare-identifier name stays unquoted.
+    expect(template).toContain('size => ')
+    expect(template).not.toContain('data-slot => ')
+  })
+})
+
+describe('MojoAdapter - nullish optional-attribute omission (textarea rows)', () => {
+  // A no-destructure-default, nillable-typed prop is `undef` when the
+  // caller omits it; guard its bare-reference attribute with Perl
+  // `defined` so it DROPS instead of rendering `attr=""` — matching
+  // Hono's nullish-attribute omission. Concrete/defaulted props are
+  // never `undef` and stay unconditional.
+  test('guards a no-default nillable attr with a Perl defined check', () => {
+    const { template } = compileAndGenerate(`
+function C({ rows }: { rows?: number }) {
+  return <textarea rows={rows} />
+}
+`)
+    expect(template).toContain('<% if (defined $rows) { %>rows="<%= $rows %>"<% } %>')
+    // Must NOT emit the bare unconditional form.
+    expect(template).not.toMatch(/(?<!\{ %>)rows="<%= \$rows %>"/)
+  })
+
+  test('leaves a defaulted attr unconditional (scope did not widen)', () => {
+    const { template } = compileAndGenerate(`
+function C({ value = '' }: { value?: string }) {
+  return <textarea value={value} />
+}
+`)
+    // `value` has a destructure default → never undef → unconditional,
+    // exactly like Hono's value="".
+    expect(template).toContain('value="<%= $value %>"')
+    expect(template).not.toContain('defined $value')
+  })
+})
+
 describe('MojoAdapter - Template Generation', () => {
   test('generates basic element with scope marker', () => {
     const result = compileAndGenerate(`