@barefootjs/mojolicious 0.16.0 → 0.17.1

package/dist/adapter/index.js

@@ -1,27 +1,24 @@
 // src/adapter/mojo-adapter.ts
-import ts from "typescript";
 import {
   BaseAdapter,
   isBooleanAttr,
   parseExpression as parseExpression2,
+  stringifyParsedExpr as stringifyParsedExpr2,
   parseStyleObjectEntries,
   isSupported,
   exprToString,
   parseProviderObjectLiteral,
-  identifierPath,
-  emitParsedExpr,
+  emitParsedExpr as emitParsedExpr2,
   emitIRNode,
   emitAttrValue,
   augmentInheritedPropAccesses,
-  parseRecordIndexAccess,
-  evalStringArrayJoin,
-  extractArrowBodyExpression,
-  collectContextConsumers,
   isLowerableObjectRestDestructure,
   collectModuleStringConsts,
   lookupStaticRecordLiteral,
   searchParamsLocalNames,
-  matchSearchParamsMethodCall
+  prepareLoweringMatchers,
+  queryHrefArgs,
+  sortComparatorFromArrow as sortComparatorFromArrow2
 } from "@barefootjs/jsx";
 
 // src/adapter/boolean-result.ts
@@ -79,6 +76,8 @@ function isAriaBooleanAttr(name) {
 
 // src/adapter/mojo-adapter.ts
 import { BF_SLOT, BF_COND, BF_REGION } from "@barefootjs/shared";
+
+// src/adapter/lib/constants.ts
 var MOJO_TEMPLATE_PRIMITIVES = {
   "JSON.stringify": { arity: 1, emit: (args) => `bf->json(${args[0]})` },
   String: { arity: 1, emit: (args) => `bf->string(${args[0]})` },
@@ -88,6 +87,16 @@ var MOJO_TEMPLATE_PRIMITIVES = {
   "Math.round": { arity: 1, emit: (args) => `bf->round(${args[0]})` }
 };
 var MOJO_PRIMITIVE_EMIT_MAP = Object.fromEntries(Object.entries(MOJO_TEMPLATE_PRIMITIVES).map(([k, v]) => [k, v.emit]));
+
+// src/adapter/lib/perl-naming.ts
+function perlHashKey(name) {
+  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : `'${name.replace(/'/g, "\\'")}'`;
+}
+function perlIdentifierFromMarkerId(markerId) {
+  return markerId.replace(/[^a-zA-Z0-9]/g, (ch) => ch === "_" ? "__" : `_x${ch.charCodeAt(0).toString(16)}`);
+}
+
+// src/adapter/lib/ir-scope.ts
 function resolveJsxChildrenProp(props) {
   const prop = props.find((p) => p.name === "children");
   if (!prop)
@@ -96,9 +105,6 @@ function resolveJsxChildrenProp(props) {
     return [];
   return prop.value.children;
 }
-function perlHashKey(name) {
-  return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : `'${name.replace(/'/g, "\\'")}'`;
-}
 function collectRootScopeNodes(node) {
   const out = new Set;
   const visit = (n) => {
@@ -122,1482 +128,1619 @@ function collectRootScopeNodes(node) {
   visit(node);
   return out;
 }
-function referencedVarsAreAvailable(expr, available) {
-  for (const m of expr.matchAll(/\$([A-Za-z_]\w*)/g)) {
-    if (!available.has(m[1]))
-      return false;
-  }
-  return true;
-}
 
-class MojoAdapter extends BaseAdapter {
-  name = "mojolicious";
-  extension = ".html.ep";
-  templatesPerComponent = true;
-  importMapInjection = "html-snippet";
-  templatePrimitives = MOJO_PRIMITIVE_EMIT_MAP;
-  componentName = "";
-  rootScopeNodes = new Set;
-  options;
-  errors = [];
-  inLoop = false;
-  propsObjectName = null;
-  propsParams = [];
-  booleanTypedProps = new Set;
-  stringValueNames = new Set;
-  _searchParamsLocals = new Set;
-  moduleStringConsts = new Map;
-  localConstants = [];
-  loopBoundNames = new Map;
-  nullableOptionalProps = new Set;
-  constructor(options = {}) {
-    super();
-    this.options = {
-      clientJsBasePath: options.clientJsBasePath ?? "/static/components/",
-      barefootJsPath: options.barefootJsPath ?? "/static/components/barefoot.js"
-    };
-  }
-  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.booleanTypedProps = new Set(ir.metadata.propsParams.filter((prop) => prop.type?.primitive === "boolean" || prop.type?.raw === "boolean").map((prop) => prop.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)) {
-        this.stringValueNames.add(s.getter);
+// src/adapter/expr/array-method.ts
+import {
+  serializeParsedExpr,
+  freeVarsInBody
+} from "@barefootjs/jsx";
+function renderArrayMethod(method, object, args, emit) {
+  switch (method) {
+    case "join": {
+      const obj = emit(object);
+      const sep = args.length >= 1 ? emit(args[0]) : `','`;
+      return `join(${sep}, @{${obj}})`;
+    }
+    case "includes": {
+      const obj = emit(object);
+      const needle = emit(args[0]);
+      return `bf->includes(${obj}, ${needle})`;
+    }
+    case "indexOf":
+    case "lastIndexOf": {
+      const fn = method === "indexOf" ? "index_of" : "last_index_of";
+      const obj = emit(object);
+      const needle = emit(args[0]);
+      return `bf->${fn}(${obj}, ${needle})`;
+    }
+    case "at": {
+      const obj = emit(object);
+      const idx = args.length >= 1 ? emit(args[0]) : "0";
+      return `bf->at(${obj}, ${idx})`;
+    }
+    case "concat": {
+      if (args.length === 0) {
+        return emit(object);
       }
+      const a = emit(object);
+      const b = emit(args[0]);
+      return `bf->concat(${a}, ${b})`;
     }
-    for (const p of ir.metadata.propsParams) {
-      if (isStringTypeInfo(p.type))
-        this.stringValueNames.add(p.name);
+    case "slice": {
+      const recv = emit(object);
+      const start = args.length >= 1 ? emit(args[0]) : "0";
+      const end = args.length >= 2 ? emit(args[1]) : "undef";
+      return `bf->slice(${recv}, ${start}, ${end})`;
     }
-    this.moduleStringConsts = collectModuleStringConsts(ir.metadata.localConstants);
-    this._searchParamsLocals = searchParamsLocalNames(ir.metadata);
-    this.localConstants = ir.metadata.localConstants ?? [];
-    this.loopBoundNames.clear();
-    this.errors = [];
-    this.childrenCaptureCounter = 0;
-    if (!options?.siblingTemplatesRegistered) {
-      this.checkImportedLoopChildComponents(ir);
+    case "reverse":
+    case "toReversed": {
+      const recv = emit(object);
+      return `bf->reverse(${recv})`;
     }
-    this.rootScopeNodes = collectRootScopeNodes(ir.root);
-    const templateBody = ir.root.type === "if-statement" ? this.renderIfStatement(ir.root) : this.renderNode(ir.root);
-    const scriptReg = options?.skipScriptRegistration ? "" : this.generateScriptRegistrations(ir, options?.scriptBaseName);
-    const ctxSeed = this.generateContextConsumerSeed(ir);
-    const memoSeed = this.generateDerivedMemoSeed(ir);
-    const template = `${scriptReg}${ctxSeed}${memoSeed}${templateBody}
-`;
-    if (this.errors.length > 0) {
-      ir.errors.push(...this.errors);
+    case "toLowerCase": {
+      const recv = emit(object);
+      return `lc(${recv})`;
     }
-    const sections = {
-      imports: "",
-      types: "",
-      component: template,
-      defaultExport: ""
-    };
-    return {
-      template,
-      sections,
-      extension: this.extension
-    };
-  }
-  isBooleanTypedPropRef(expr) {
-    let bare = expr.trim();
-    if (this.propsObjectName && bare.startsWith(`${this.propsObjectName}.`)) {
-      bare = bare.slice(this.propsObjectName.length + 1);
+    case "toUpperCase": {
+      const recv = emit(object);
+      return `uc(${recv})`;
+    }
+    case "trim": {
+      const recv = emit(object);
+      return `bf->trim(${recv})`;
+    }
+    case "toFixed": {
+      const recv = emit(object);
+      const digits = args.length >= 1 ? emit(args[0]) : "0";
+      return `bf->to_fixed(${recv}, ${digits})`;
+    }
+    case "split": {
+      const recv = emit(object);
+      if (args.length === 0) {
+        return `bf->split(${recv})`;
+      }
+      const sep = emit(args[0]);
+      if (args.length === 1) {
+        return `bf->split(${recv}, ${sep})`;
+      }
+      const limit = emit(args[1]);
+      return `bf->split(${recv}, ${sep}, ${limit})`;
+    }
+    case "startsWith":
+    case "endsWith": {
+      const fn = method === "startsWith" ? "starts_with" : "ends_with";
+      const recv = emit(object);
+      const arg = emit(args[0]);
+      if (args.length >= 2) {
+        return `bf->${fn}(${recv}, ${arg}, ${emit(args[1])})`;
+      }
+      return `bf->${fn}(${recv}, ${arg})`;
+    }
+    case "replace": {
+      const recv = emit(object);
+      const oldS = emit(args[0]);
+      const newS = emit(args[1]);
+      return `bf->replace(${recv}, ${oldS}, ${newS})`;
+    }
+    case "repeat": {
+      const recv = emit(object);
+      const count = args.length === 0 ? "0" : emit(args[0]);
+      return `bf->repeat(${recv}, ${count})`;
+    }
+    case "padStart":
+    case "padEnd": {
+      const fn = method === "padStart" ? "pad_start" : "pad_end";
+      const recv = emit(object);
+      if (args.length === 0) {
+        return `bf->${fn}(${recv}, 0)`;
+      }
+      const target = emit(args[0]);
+      if (args.length === 1) {
+        return `bf->${fn}(${recv}, ${target})`;
+      }
+      const pad = emit(args[1]);
+      return `bf->${fn}(${recv}, ${target}, ${pad})`;
+    }
+    default: {
+      const _exhaustive = method;
+      throw new Error(`renderArrayMethod: unhandled ArrayMethod '${_exhaustive}'`);
     }
-    if (!/^[A-Za-z_$][\w$]*$/.test(bare))
-      return false;
-    return this.booleanTypedProps.has(bare);
   }
-  parseUndefinedAlternateTernary(expr) {
-    const parsed = parseExpression2(expr.trim());
-    if (parsed?.kind !== "conditional")
-      return null;
-    const alt = parsed.alternate;
-    const isUndef = alt.kind === "identifier" && (alt.name === "undefined" || alt.name === "null") || alt.kind === "literal" && (alt.value === null || alt.value === undefined);
-    if (!isUndef)
-      return null;
-    return {
-      condition: exprToString(parsed.test),
-      consequent: exprToString(parsed.consequent)
-    };
+}
+function escapePerlSingleQuote(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function emitEvalEnvArg(body, params, emit) {
+  const free = freeVarsInBody(body, new Set(params));
+  if (free.length === 0)
+    return "{}";
+  const pairs = free.map((n) => `'${escapePerlSingleQuote(n)}' => ${emit({ kind: "identifier", name: n })}`);
+  return `{ ${pairs.join(", ")} }`;
+}
+function renderSortEval(recv, body, params, emit) {
+  if (params.length < 2)
+    return null;
+  const [paramA, paramB] = params;
+  const json = serializeParsedExpr(body);
+  if (json === null)
+    return null;
+  const env = emitEvalEnvArg(body, [paramA, paramB], emit);
+  return `bf->sort_eval(${recv}, '${escapePerlSingleQuote(json)}', '${paramA}', '${paramB}', ${env})`;
+}
+function renderReduceEval(recv, body, params, init, direction, emit) {
+  if (params.length < 2)
+    return null;
+  const [paramAcc, paramItem] = params;
+  const json = serializeParsedExpr(body);
+  if (json === null)
+    return null;
+  let initPerl;
+  if (init.kind === "literal" && init.literalType === "string") {
+    initPerl = `'${escapePerlSingleQuote(String(init.value))}'`;
+  } else if (init.kind === "literal" && init.literalType === "number") {
+    initPerl = String(init.value);
+  } else {
+    return null;
   }
-  resolveLiteralConst(name) {
-    if (this.loopBoundNames?.has?.(name))
-      return null;
-    const c = (this.localConstants ?? []).find((lc) => lc.name === name);
-    if (c?.value === undefined)
-      return null;
-    const v = c.value.trim();
-    if (/^-?\d+(\.\d+)?$/.test(v))
-      return v;
-    const strLit = /^'([^'\\]*)'$/.exec(v) ?? /^"([^"\\]*)"$/.exec(v);
-    if (strLit)
-      return `'${strLit[1].replace(/[\\']/g, (m) => `\\${m}`)}'`;
+  const env = emitEvalEnvArg(body, [paramAcc, paramItem], emit);
+  return `bf->reduce_eval(${recv}, '${escapePerlSingleQuote(json)}', '${paramAcc}', '${paramItem}', ${initPerl}, '${direction}', ${env})`;
+}
+function renderPredicateEval(funcName, recv, predicate, param, emit, forward) {
+  const json = serializeParsedExpr(predicate);
+  if (json === null)
+    return null;
+  const env = emitEvalEnvArg(predicate, [param], emit);
+  const fwd = forward === undefined ? "" : `, ${forward ? 1 : 0}`;
+  return `bf->${funcName}(${recv}, '${escapePerlSingleQuote(json)}', '${param}'${fwd}, ${env})`;
+}
+function renderFlatMapEval(recv, body, param, emit) {
+  const json = serializeParsedExpr(body);
+  if (json === null)
+    return null;
+  const env = emitEvalEnvArg(body, [param], emit);
+  return `bf->flat_map_eval(${recv}, '${escapePerlSingleQuote(json)}', '${param}', ${env})`;
+}
+function renderMapEval(recv, body, param, emit) {
+  const json = serializeParsedExpr(body);
+  if (json === null)
     return null;
+  const env = emitEvalEnvArg(body, [param], emit);
+  return `bf->map_eval(${recv}, '${escapePerlSingleQuote(json)}', '${param}', ${env})`;
+}
+function renderSortMethod(recv, c) {
+  const keyHashes = c.keys.map((k) => {
+    const keyEntry = k.key.kind === "self" ? `key_kind => 'self'` : `key_kind => 'field', key => '${k.key.field}'`;
+    return `{ ${keyEntry}, compare_type => '${k.type}', direction => '${k.direction}' }`;
+  });
+  return `bf->sort(${recv}, { keys => [${keyHashes.join(", ")}] })`;
+}
+function renderFlatMethod(recv, depth) {
+  const d = depth === "infinity" ? -1 : depth;
+  return `bf->flat(${recv}, ${d})`;
+}
+
+// src/adapter/expr/emitters.ts
+import {
+  emitParsedExpr,
+  identifierPath,
+  matchSearchParamsMethodCall,
+  sortComparatorFromArrow,
+  asCallbackMethodCall
+} from "@barefootjs/jsx";
+
+// src/adapter/expr/operand.ts
+function isStringTypedOperand(expr, isStringName) {
+  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);
   }
-  resolveStaticRecordLiteral(objectName, key) {
-    if (this.loopBoundNames?.has?.(objectName))
-      return null;
-    const hit = lookupStaticRecordLiteral(objectName, key, this.localConstants);
-    if (!hit)
-      return null;
-    return hit.kind === "number" ? hit.text : `'${hit.text.replace(/[\\']/g, (m) => `\\${m}`)}'`;
+  if (expr.kind === "member" && expr.object.kind === "identifier" && expr.object.name === "props") {
+    return isStringName(expr.property);
   }
-  resolveModuleStringConst(name) {
-    if (this.loopBoundNames.has(name))
-      return null;
-    const value = this.moduleStringConsts.get(name);
-    if (value === undefined)
-      return null;
-    return `'${value.replace(/[\\']/g, (m) => `\\${m}`)}'`;
+  return false;
+}
+function emitIndexAccessPerl(object, index, emit, isStringName) {
+  const i = emit(index);
+  return isStringTypedOperand(index, isStringName) ? `${emit(object)}->{${i}}` : `${emit(object)}->[${i}]`;
+}
+
+// src/adapter/expr/emitters.ts
+var PREDICATE_METHODS = new Set([
+  "filter",
+  "find",
+  "findIndex",
+  "findLast",
+  "findLastIndex",
+  "every",
+  "some"
+]);
+
+class MojoFilterEmitter {
+  param;
+  localVarMap;
+  isStringName;
+  onUnsupported;
+  constructor(param, localVarMap, isStringName = () => false, onUnsupported) {
+    this.param = param;
+    this.localVarMap = localVarMap;
+    this.isStringName = isStringName;
+    this.onUnsupported = onUnsupported;
   }
-  generateScriptRegistrations(ir, scriptBaseName) {
-    const hasInteractivity = this.hasClientInteractivity(ir);
-    if (!hasInteractivity)
-      return "";
-    const name = scriptBaseName ?? ir.metadata.componentName;
-    const runtimePath = this.options.barefootJsPath;
-    const clientJsPath = `${this.options.clientJsBasePath}${name}.client.js`;
-    const lines = [];
-    lines.push(`% bf->register_script('${runtimePath}');`);
-    lines.push(`% bf->register_script('${clientJsPath}');`);
-    lines.push("");
-    return lines.join(`
-`);
+  identifier(name) {
+    if (name === this.param)
+      return `$${this.param}`;
+    const signal = this.localVarMap.get(name);
+    if (signal)
+      return `$${signal}`;
+    return `$${name}`;
   }
-  hasClientInteractivity(ir) {
-    return ir.metadata.signals.length > 0 || ir.metadata.effects.length > 0 || ir.metadata.onMounts.length > 0 || (ir.metadata.clientAnalysis?.needsInit ?? false);
+  literal(value, literalType) {
+    if (literalType === "string")
+      return `'${value}'`;
+    if (literalType === "boolean")
+      return value ? "1" : "0";
+    if (literalType === "null")
+      return "undef";
+    return String(value);
   }
-  renderNode(node) {
-    return emitIRNode(node, this, {});
+  member(object, property, _computed, emit) {
+    if (property === "length" && (asCallbackMethodCall(object) !== null || object.kind === "array-literal")) {
+      return `scalar(@{${emit(object)}})`;
+    }
+    return `${emit(object)}->{${property}}`;
   }
-  emitElement(node, _ctx, _emit) {
-    return this.renderElement(node);
+  indexAccess(object, index, emit) {
+    return emitIndexAccessPerl(object, index, emit, this.isStringName);
   }
-  emitText(node) {
-    return node.value;
+  call(callee, args, emit) {
+    if (callee.kind === "identifier" && args.length === 0) {
+      return `$${callee.name}`;
+    }
+    return emit(callee);
   }
-  emitExpression(node) {
-    return this.renderExpression(node);
+  unary(op, argument, emit) {
+    const arg = emit(argument);
+    if (op === "!") {
+      const needsParens = argument.kind === "binary" || argument.kind === "logical";
+      return needsParens ? `!(${arg})` : `!${arg}`;
+    }
+    if (op === "-")
+      return `-${arg}`;
+    return arg;
   }
-  emitConditional(node, _ctx, _emit) {
-    return this.renderConditional(node);
+  binary(op, left, right, emit) {
+    const l = emit(left);
+    const r = emit(right);
+    const isStr = (e) => isStringTypedOperand(e, this.isStringName);
+    const stringCmp = isStr(left) || isStr(right);
+    if ((op === "===" || op === "==") && stringCmp) {
+      return `${l} eq ${r}`;
+    }
+    if ((op === "!==" || op === "!=") && stringCmp) {
+      return `${l} ne ${r}`;
+    }
+    const opMap = {
+      "===": "==",
+      "!==": "!=",
+      ">": ">",
+      "<": "<",
+      ">=": ">=",
+      "<=": "<=",
+      "+": "+",
+      "-": "-",
+      "*": "*",
+      "/": "/"
+    };
+    return `${l} ${opMap[op] ?? op} ${r}`;
   }
-  emitLoop(node, _ctx, _emit) {
-    return this.renderLoop(node);
+  logical(op, left, right, emit) {
+    const l = emit(left);
+    const r = emit(right);
+    if (op === "&&")
+      return `(${l} && ${r})`;
+    if (op === "||")
+      return `(${l} || ${r})`;
+    return `(${l} // ${r})`;
   }
-  emitComponent(node, _ctx, _emit) {
-    return this.renderComponent(node);
+  callbackMethod(method, object, arrow, _restArgs, emit) {
+    if (!PREDICATE_METHODS.has(method)) {
+      this.onUnsupported?.(`Filter predicate contains a nested '.${method}(...)' callback, which has no Perl scalar form`, `Rewrite the predicate without a nested callback method, or add /* @client */ for client-only evaluation (no SSR).`);
+      return "1";
+    }
+    const param = arrow.params[0];
+    const predicate = arrow.body;
+    const arrayExpr = emit(object);
+    const predBody = emitParsedExpr(predicate, new MojoFilterEmitter(param, this.localVarMap, this.isStringName, this.onUnsupported));
+    const grepBody = predBody.replace(new RegExp(`\\$${param}\\b`, "g"), "$_");
+    if (method === "filter")
+      return `[grep { ${grepBody} } @{${arrayExpr}}]`;
+    if (method === "every")
+      return `!(grep { !(${grepBody}) } @{${arrayExpr}})`;
+    if (method === "some")
+      return `!!(grep { ${grepBody} } @{${arrayExpr}})`;
+    this.onUnsupported?.(`Filter predicate contains a nested '.${method}(...)' callback, which has no Perl scalar form`, `Rewrite the predicate without a nested callback method, or add /* @client */ for client-only evaluation (no SSR).`);
+    return arrayExpr;
   }
-  emitFragment(node, _ctx, _emit) {
-    return this.renderFragment(node);
+  arrayLiteral(elements, emit) {
+    return `[${elements.map(emit).join(", ")}]`;
   }
-  emitSlot(node) {
-    return this.renderSlot(node);
+  arrayMethod(method, object, args, emit) {
+    return renderArrayMethod(method, object, args, emit);
   }
-  emitIfStatement(node, _ctx, _emit) {
-    return this.renderIfStatement(node);
+  flatMethod(object, depth, emit) {
+    return renderFlatMethod(emit(object), depth);
   }
-  emitProvider(node, _ctx, _emit) {
-    const value = this.providerValuePerl(node.valueProp);
-    const children = this.renderChildren(node.children);
-    const name = node.contextName;
-    return `<% bf->provide_context('${name}', ${value}); %>` + children + `<% bf->revoke_context('${name}'); %>`;
+  conditional(_test, _consequent, _alternate) {
+    return "1";
   }
-  providerValuePerl(valueProp) {
-    const v = valueProp.value;
-    if (v.kind === "literal") {
-      return typeof v.value === "string" ? `'${v.value.replace(/[\\']/g, (m) => `\\${m}`)}'` : String(v.value);
-    }
-    if (v.kind === "expression") {
-      const hashref = this.providerObjectLiteralPerl(v.expr);
-      if (hashref !== null)
-        return hashref;
-      return this.convertExpressionToPerl(v.expr);
-    }
-    if (v.kind === "template")
-      return this.convertTemplateLiteralPartsToPerl(v.parts);
-    return "undef";
+  templateLiteral(_parts) {
+    return "1";
   }
-  providerObjectLiteralPerl(expr) {
-    const members = parseProviderObjectLiteral(expr.trim());
-    if (members === null)
-      return null;
-    const entries = members.map((m) => {
-      const key = `'${m.name.replace(/[\\']/g, (c) => `\\${c}`)}'`;
-      if (m.kind === "function" || /^on[A-Z]/.test(m.name))
-        return `${key} => undef`;
-      const src = m.kind === "getter" ? m.body : m.expr;
-      return `${key} => ${this.convertExpressionToPerl(src)}`;
-    });
-    return `{ ${entries.join(", ")} }`;
+  arrow(_params, _body, _emit) {
+    return "1";
   }
-  contextDefaultPerl(c) {
-    const d = c.defaultValue;
-    if (d === null || d === undefined)
-      return "undef";
-    if (typeof d === "string")
-      return `'${d.replace(/[\\']/g, (m) => `\\${m}`)}'`;
-    if (typeof d === "boolean")
-      return d ? "1" : "0";
-    return String(d);
-  }
-  generateContextConsumerSeed(ir) {
-    const consumers = collectContextConsumers(ir.metadata);
-    if (consumers.length === 0)
-      return "";
-    return consumers.map((c) => `% my $${c.localName} = bf->use_context('${c.contextName}', ${this.contextDefaultPerl(c)});`).join(`
-`) + `
-`;
+  regex(_raw) {
+    return "1";
   }
-  generateDerivedMemoSeed(ir) {
-    const memos = ir.metadata.memos ?? [];
-    const signals = ir.metadata.signals ?? [];
-    if (memos.length === 0 && signals.length === 0)
-      return "";
-    const available = new Set(ir.metadata.propsParams.map((p) => p.name));
-    const lines = [];
-    for (const signal of signals) {
-      const perl = this.tryLowerToPerl(signal.initialValue, available);
-      if (perl !== null)
-        lines.push(`% my $${signal.getter} = ${perl};`);
-      available.add(signal.getter);
-    }
-    for (const memo of memos) {
-      const body = extractArrowBodyExpression(memo.computation);
-      if (body !== null) {
-        const perl = this.tryLowerToPerl(body, available);
-        if (perl !== null)
-          lines.push(`% my $${memo.name} = ${perl};`);
-      }
-      available.add(memo.name);
-    }
-    return lines.length > 0 ? lines.join(`
-`) + `
-` : "";
+  unsupported(_raw, _reason) {
+    return "1";
   }
-  tryLowerToPerl(expr, available) {
-    const trimmed = expr.trim();
-    if (!trimmed)
-      return null;
-    if (!isSupported(parseExpression2(trimmed)).supported)
-      return null;
-    const perl = this.convertExpressionToPerl(trimmed);
-    if (perl === "" || !/\$[A-Za-z_]\w*/.test(perl))
-      return null;
-    return referencedVarsAreAvailable(perl, available) ? perl : null;
+  objectLiteral(_properties, _raw, _emit) {
+    return "1";
   }
-  emitAsync(node, _ctx, _emit) {
-    return this.renderAsync(node);
+}
+
+class MojoTopLevelEmitter {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
   }
-  renderElement(element) {
-    const tag = element.tag;
-    const attrs = this.renderAttributes(element);
-    const children = this.renderChildren(element.children);
-    let hydrationAttrs = "";
-    if (element.needsScope) {
-      hydrationAttrs += ` ${this.renderScopeMarker("")}`;
+  identifier(name) {
+    if (name === "undefined" || name === "null")
+      return "undef";
+    const inlined = this.ctx.resolveModuleStringConst(name);
+    if (inlined !== null)
+      return inlined;
+    const literalConst = this.ctx.resolveLiteralConst(name);
+    if (literalConst !== null)
+      return literalConst;
+    return `$${name}`;
+  }
+  literal(value, literalType) {
+    if (literalType === "string")
+      return `'${value}'`;
+    if (literalType === "boolean")
+      return value ? "1" : "0";
+    if (literalType === "null")
+      return "undef";
+    return String(value);
+  }
+  member(object, property, _computed, emit) {
+    if (object.kind === "identifier" && object.name === "props") {
+      return `$${property}`;
     }
-    if (this.rootScopeNodes.has(element) && element.needsScope) {
-      hydrationAttrs += ` <%== bf->data_key_attr %>`;
+    if (object.kind === "identifier") {
+      const staticValue = this.ctx.resolveStaticRecordLiteral(object.name, property);
+      if (staticValue !== null)
+        return staticValue;
     }
-    if (element.slotId) {
-      hydrationAttrs += ` ${this.renderSlotMarker(element.slotId)}`;
+    const obj = emit(object);
+    if (property === "length")
+      return `scalar(@{${obj}})`;
+    return `${obj}->{${property}}`;
+  }
+  indexAccess(object, index, emit) {
+    return emitIndexAccessPerl(object, index, emit, (n) => this.ctx._isStringValueName(n));
+  }
+  call(callee, args, emit) {
+    if (callee.kind === "identifier" && args.length === 0) {
+      return `$${callee.name}`;
     }
-    if (element.regionId) {
-      hydrationAttrs += ` ${BF_REGION}="${element.regionId}"`;
+    if (this.ctx._searchParamsLocals.size > 0) {
+      const sp = matchSearchParamsMethodCall(callee, args, this.ctx._searchParamsLocals);
+      if (sp) {
+        return `$searchParams->${sp.method}(${sp.args.map(emit).join(", ")})`;
+      }
     }
-    const voidElements = [
-      "area",
-      "base",
-      "br",
-      "col",
-      "embed",
-      "hr",
-      "img",
-      "input",
-      "link",
-      "meta",
-      "param",
-      "source",
-      "track",
-      "wbr"
-    ];
-    if (voidElements.includes(tag.toLowerCase())) {
-      return `<${tag}${attrs}${hydrationAttrs}>`;
+    const path = identifierPath(callee);
+    const spec = path ? MOJO_TEMPLATE_PRIMITIVES[path] : undefined;
+    if (path && spec) {
+      if (args.length === spec.arity) {
+        return spec.emit(args.map(emit));
+      }
+      this.ctx._recordExprBF101(`templatePrimitive '${path}' expects ${spec.arity} arg(s), got ${args.length}`, `Call '${path}' with exactly ${spec.arity} argument(s).`);
+      return "''";
     }
-    return `<${tag}${attrs}${hydrationAttrs}>${children}</${tag}>`;
+    return emit(callee);
   }
-  renderExpression(expr) {
-    if (expr.clientOnly) {
-      if (expr.slotId) {
-        return `<%== bf->comment("client:${expr.slotId}") %>`;
-      }
-      return "";
+  unary(op, argument, emit) {
+    const arg = emit(argument);
+    if (op === "!")
+      return `!${arg}`;
+    if (op === "-")
+      return `-${arg}`;
+    return arg;
+  }
+  binary(op, left, right, emit) {
+    const l = emit(left);
+    const r = emit(right);
+    const isStr = (e) => isStringTypedOperand(e, (n) => this.ctx._isStringValueName(n));
+    const stringCmp = isStr(left) || isStr(right);
+    if ((op === "===" || op === "==") && stringCmp) {
+      return `${l} eq ${r}`;
     }
-    const perlExpr = this.convertExpressionToPerl(expr.expr);
-    if (expr.slotId) {
-      return `<%== bf->text_start("${expr.slotId}") %><%= ${perlExpr} %><%== bf->text_end %>`;
+    if ((op === "!==" || op === "!=") && stringCmp) {
+      return `${l} ne ${r}`;
     }
-    return `<%= ${perlExpr} %>`;
+    const opMap = {
+      "===": "==",
+      "!==": "!=",
+      ">": ">",
+      "<": "<",
+      ">=": ">=",
+      "<=": "<=",
+      "+": "+",
+      "-": "-",
+      "*": "*"
+    };
+    return `${l} ${opMap[op] ?? op} ${r}`;
   }
-  renderConditional(cond) {
-    if (cond.clientOnly && cond.slotId) {
-      return `<%== bf->comment("cond-start:${cond.slotId}") %><%== bf->comment("cond-end:${cond.slotId}") %>`;
+  logical(op, left, right, emit) {
+    const l = emit(left);
+    const r = emit(right);
+    if (op === "&&")
+      return `(${l} && ${r})`;
+    if (op === "||")
+      return `(${l} || ${r})`;
+    return `(${l} // ${r})`;
+  }
+  callbackMethod(method, object, arrow, restArgs, emit) {
+    const recv = emit(object);
+    const body = arrow.body;
+    const params = arrow.params;
+    if (method === "sort" || method === "toSorted") {
+      const evalForm = renderSortEval(recv, body, params, emit);
+      if (evalForm !== null)
+        return evalForm;
+      const c = sortComparatorFromArrow(arrow);
+      if (c !== null)
+        return renderSortMethod(recv, c);
+      this.ctx._recordExprBF101(`.${method}(...) comparator is not lowerable to a template sort`, `Pre-sort the array in the route handler, or mark the loop @client-only.`);
+      return "''";
     }
-    const condition = this.convertExpressionToPerl(cond.condition);
-    const whenTrue = this.renderNode(cond.whenTrue);
-    const whenFalse = this.renderNodeOrNull(cond.whenFalse);
-    const isFragmentBranch = cond.whenTrue.type === "fragment" || cond.whenFalse.type === "fragment";
-    const useCommentMarkers = cond.slotId && isFragmentBranch;
-    let markedTrue = whenTrue;
-    let markedFalse = whenFalse;
-    if (cond.slotId && !useCommentMarkers) {
-      markedTrue = this.addCondMarkerToFirstElement(whenTrue, cond.slotId);
-      markedFalse = whenFalse ? this.addCondMarkerToFirstElement(whenFalse, cond.slotId) : whenFalse;
+    if (method === "reduce" || method === "reduceRight") {
+      const direction = method === "reduceRight" ? "right" : "left";
+      const init = restArgs[0];
+      const evalForm = init !== undefined ? renderReduceEval(recv, body, params, init, direction, emit) : null;
+      if (evalForm !== null)
+        return evalForm;
+      this.ctx._recordExprBF101(`.${method}(...) is not lowerable to a template fold`, `Pre-compute the fold in the route handler, or mark the loop @client-only.`);
+      return "''";
     }
-    let result;
-    if (useCommentMarkers) {
-      const inner = whenFalse ? `
-% if (${condition}) {
-${whenTrue}
-% } else {
-${whenFalse}
-% }
-` : `
-% if (${condition}) {
-${whenTrue}
-% }
-`;
-      result = `<%== bf->comment("cond-start:${cond.slotId}") %>${inner}<%== bf->comment("cond-end:${cond.slotId}") %>`;
-    } else if (markedFalse) {
-      result = `
-% if (${condition}) {
-${markedTrue}
-% } else {
-${markedFalse}
-% }
-`;
-    } else if (cond.slotId) {
-      result = `<%== bf->comment("cond-start:${cond.slotId}") %>
-% if (${condition}) {
-${whenTrue}
-% }
-<%== bf->comment("cond-end:${cond.slotId}") %>`;
-    } else {
-      result = `
-% if (${condition}) {
-${whenTrue}
-% }
-`;
+    if (method === "flatMap") {
+      const evalForm = renderFlatMapEval(recv, body, params[0], emit);
+      if (evalForm !== null)
+        return evalForm;
+      this.ctx._recordExprBF101(`.flatMap(...) projection is not lowerable to a template flat-map`, `Pre-compute the projection in the route handler, or mark the loop @client-only.`);
+      return "''";
     }
-    return result;
-  }
-  renderNodeOrNull(node) {
-    if (node.type === "expression" && (node.expr === "null" || node.expr === "undefined")) {
-      return null;
+    if (method === "map") {
+      const evalForm = renderMapEval(recv, body, params[0], emit);
+      if (evalForm !== null)
+        return evalForm;
+      this.ctx._recordExprBF101(`.map(...) projection is not lowerable to a template map`, `Pre-compute the projection in the route handler, or mark the position @client-only.`);
+      return "''";
     }
-    return this.renderNode(node);
-  }
-  addCondMarkerToFirstElement(content, condId) {
-    const match = content.match(/^(<\w+)([\s>])/);
-    if (match) {
-      return content.replace(/^(<\w+)([\s>])/, `$1 ${BF_COND}="${condId}"$2`);
+    const cb = {
+      method,
+      object,
+      param: params[0],
+      predicate: body
+    };
+    return this.renderPredicate(cb, recv, emit);
+  }
+  renderPredicate(cb, arrayExpr, emit) {
+    const { method, param, predicate } = cb;
+    const evalFn = {
+      filter: ["filter_eval"],
+      every: ["every_eval"],
+      some: ["some_eval"],
+      find: ["find_eval", true],
+      findLast: ["find_eval", false],
+      findIndex: ["find_index_eval", true],
+      findLastIndex: ["find_index_eval", false]
+    };
+    const isIdentity = method === "filter" && predicate.kind === "identifier" && predicate.name === param;
+    const spec = evalFn[method];
+    if (spec && !isIdentity) {
+      const evalForm = renderPredicateEval(spec[0], arrayExpr, predicate, param, emit, spec[1]);
+      if (evalForm !== null)
+        return evalForm;
+    }
+    const predBody = this.ctx._renderPerlFilterExprPublic(predicate, param);
+    const grepBody = predBody.replace(new RegExp(`\\$${param}\\b`, "g"), "$_");
+    if (method === "filter")
+      return `[grep { ${grepBody} } @{${arrayExpr}}]`;
+    if (method === "every")
+      return `!(grep { !(${grepBody}) } @{${arrayExpr}})`;
+    if (method === "some")
+      return `!!(grep { ${grepBody} } @{${arrayExpr}})`;
+    const findHelper = {
+      find: "find",
+      findIndex: "find_index",
+      findLast: "find_last",
+      findLastIndex: "find_last_index"
+    };
+    if (findHelper[method]) {
+      return `bf->${findHelper[method]}(${arrayExpr}, sub { my $${param} = $_[0]; ${predBody} })`;
     }
-    return `<%== bf->comment("cond-start:${condId}") %>${content}<%== bf->comment("cond-end:${condId}") %>`;
+    return arrayExpr;
   }
-  checkImportedLoopChildComponents(ir) {
-    const relativeImports = new Set;
-    for (const imp of ir.metadata.templateImports ?? ir.metadata.imports ?? []) {
-      if (!imp.source.startsWith("./") && !imp.source.startsWith("../"))
-        continue;
-      if (imp.isTypeOnly)
-        continue;
-      for (const spec of imp.specifiers) {
-        relativeImports.add(spec.alias ?? spec.name);
+  arrayLiteral(elements, emit) {
+    return `[${elements.map(emit).join(", ")}]`;
+  }
+  arrayMethod(method, object, args, emit) {
+    return renderArrayMethod(method, object, args, emit);
+  }
+  flatMethod(object, depth, emit) {
+    return renderFlatMethod(emit(object), depth);
+  }
+  conditional(test, consequent, alternate, emit) {
+    return `(${emit(test)} ? ${emit(consequent)} : ${emit(alternate)})`;
+  }
+  templateLiteral(parts, emit) {
+    const terms = [];
+    for (const part of parts) {
+      if (part.type === "string") {
+        if (part.value !== "") {
+          terms.push(`"${part.value.replace(/[\\"$@]/g, (m) => `\\${m}`)}"`);
+        }
+      } else {
+        const rendered = emit(part.expr);
+        const needsParens = part.expr.kind === "binary" || part.expr.kind === "logical" || part.expr.kind === "conditional";
+        terms.push(needsParens ? `(${rendered})` : rendered);
       }
     }
-    if (relativeImports.size === 0)
-      return;
-    const loc = { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } };
-    const visit = (node, inLoop) => {
-      switch (node.type) {
-        case "component": {
-          const comp = node;
-          if (inLoop && relativeImports.has(comp.name)) {
-            this.errors.push({
-              code: "BF103",
-              severity: "error",
-              message: `Component <${comp.name}> is imported from a sibling module and used inside a loop. The Mojo adapter emits a cross-template call; the child template must be registered alongside the parent at render time.`,
-              loc: comp.loc ?? loc,
-              suggestion: {
-                message: `Options:
+    if (terms.length === 0)
+      return '""';
+    return terms.join(" . ");
+  }
+  arrow(_params, _body, _emit) {
+    return "''";
+  }
+  regex(_raw) {
+    return "''";
+  }
+  unsupported(_raw, _reason) {
+    return "''";
+  }
+  objectLiteral(_properties, _raw, _emit) {
+    return "''";
+  }
+}
+
+// src/adapter/analysis/component-tree.ts
+function hasClientInteractivity(ir) {
+  return ir.metadata.signals.length > 0 || ir.metadata.effects.length > 0 || ir.metadata.onMounts.length > 0 || (ir.metadata.clientAnalysis?.needsInit ?? false);
+}
+function collectImportedLoopChildComponentErrors(ir, componentName) {
+  const errors = [];
+  const relativeImports = new Set;
+  for (const imp of ir.metadata.templateImports ?? ir.metadata.imports ?? []) {
+    if (!imp.source.startsWith("./") && !imp.source.startsWith("../"))
+      continue;
+    if (imp.isTypeOnly)
+      continue;
+    for (const spec of imp.specifiers) {
+      relativeImports.add(spec.alias ?? spec.name);
+    }
+  }
+  if (relativeImports.size === 0)
+    return errors;
+  const loc = { file: componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } };
+  const visit = (node, inLoop) => {
+    switch (node.type) {
+      case "component": {
+        const comp = node;
+        if (inLoop && relativeImports.has(comp.name)) {
+          errors.push({
+            code: "BF103",
+            severity: "error",
+            message: `Component <${comp.name}> is imported from a sibling module and used inside a loop. The Mojo adapter emits a cross-template call; the child template must be registered alongside the parent at render time.`,
+            loc: comp.loc ?? loc,
+            suggestion: {
+              message: `Options:
 ` + `  1. Compile '${comp.name}' (its source file) with the same adapter and register the resulting Mojo template alongside the parent at render time.
 ` + `  2. Inline <${comp.name}> directly inside the loop body so no cross-file template lookup is needed.
 ` + `  3. Mark the loop position as @client-only so the template is materialised on the client instead of at SSR time.`
-              }
-            });
-          }
-          for (const child of comp.children)
-            visit(child, inLoop);
-          break;
-        }
-        case "element":
-          for (const child of node.children)
-            visit(child, inLoop);
-          break;
-        case "fragment":
-          for (const child of node.children)
-            visit(child, inLoop);
-          break;
-        case "conditional": {
-          const cond = node;
-          visit(cond.whenTrue, inLoop);
-          if (cond.whenFalse)
-            visit(cond.whenFalse, inLoop);
-          break;
-        }
-        case "loop":
-          for (const child of node.children)
-            visit(child, true);
-          break;
-        case "if-statement": {
-          const stmt = node;
-          visit(stmt.consequent, inLoop);
-          if (stmt.alternate)
-            visit(stmt.alternate, inLoop);
-          break;
-        }
-        case "provider":
-          for (const child of node.children)
-            visit(child, inLoop);
-          break;
-        case "async": {
-          const a = node;
-          visit(a.fallback, inLoop);
-          for (const child of a.children)
-            visit(child, inLoop);
-          break;
+            }
+          });
         }
+        for (const child of comp.children)
+          visit(child, inLoop);
+        break;
       }
-    };
-    visit(ir.root, false);
+      case "element":
+        for (const child of node.children)
+          visit(child, inLoop);
+        break;
+      case "fragment":
+        for (const child of node.children)
+          visit(child, inLoop);
+        break;
+      case "conditional": {
+        const cond = node;
+        visit(cond.whenTrue, inLoop);
+        if (cond.whenFalse)
+          visit(cond.whenFalse, inLoop);
+        break;
+      }
+      case "loop":
+        for (const child of node.children)
+          visit(child, true);
+        break;
+      case "if-statement": {
+        const stmt = node;
+        visit(stmt.consequent, inLoop);
+        if (stmt.alternate)
+          visit(stmt.alternate, inLoop);
+        break;
+      }
+      case "provider":
+        for (const child of node.children)
+          visit(child, inLoop);
+        break;
+      case "async": {
+        const a = node;
+        visit(a.fallback, inLoop);
+        for (const child of a.children)
+          visit(child, inLoop);
+        break;
+      }
+    }
+  };
+  visit(ir.root, false);
+  return errors;
+}
+
+// src/adapter/spread/spread-codegen.ts
+import ts from "typescript";
+import { parseRecordIndexAccess, stringifyParsedExpr } from "@barefootjs/jsx";
+function conditionalSpreadToPerl(ctx, expr) {
+  if (!expr || expr.kind !== "conditional")
+    return null;
+  const whenTrue = expr.consequent;
+  const whenFalse = expr.alternate;
+  if (whenTrue.kind !== "object-literal" || whenFalse.kind !== "object-literal") {
+    return null;
   }
-  renderLoop(loop) {
-    if (loop.clientOnly)
-      return "";
-    const destructure = !!(loop.paramBindings && loop.paramBindings.length > 0);
-    const supportableDestructure = destructure && isLowerableObjectRestDestructure(loop);
-    if (destructure && !supportableDestructure) {
-      this.errors.push({
-        code: "BF104",
+  const condPerl = ctx.convertExpressionToPerl("", expr.test);
+  const truePerl = objectLiteralToPerlHashref(ctx, whenTrue);
+  const falsePerl = objectLiteralToPerlHashref(ctx, whenFalse);
+  if (truePerl === null || falsePerl === null)
+    return null;
+  return `${condPerl} ? ${truePerl} : ${falsePerl}`;
+}
+function objectLiteralExprToPerlHashref(ctx, expr) {
+  if (!expr || expr.kind !== "object-literal")
+    return null;
+  return objectLiteralToPerlHashref(ctx, expr);
+}
+function objectLiteralToPerlHashref(ctx, obj) {
+  const entries = [];
+  for (const prop of obj.properties) {
+    if (prop.shorthand)
+      return null;
+    if (prop.keyKind === "numeric")
+      return null;
+    const key = prop.key;
+    const val = prop.value;
+    const indexed = recordIndexAccessToPerl(ctx, val);
+    if (indexed === null && val.kind === "index-access" && !isLiteralIndex(val.index)) {
+      ctx.errors.push({
+        code: "BF101",
         severity: "error",
-        message: `Loop callback uses an array/object destructure pattern (\`${loop.param}\`) that the Mojo adapter cannot lower — Perl scalar bindings can't unpack a tuple in a single \`my\` declaration.`,
-        loc: loop.loc ?? { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+        message: `Spread object value '${stringifyParsedExpr(val)}' indexes a record map whose values aren't scalar literals — it can't lower to an inline Perl hashref.`,
+        loc: { file: ctx.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
         suggestion: {
-          message: `Options:
-` + `  1. Rename the parameter to a single name and access tuple elements with index syntax in the body (e.g. \`entry => entry->[0]\` instead of \`([k, v]) => ...\`).
-` + `  2. Mark the loop position as @client-only so the destructure runs in JS on the client.
-` + `  3. Move the loop into a primitive that the adapter registers explicitly.`
+          message: "Index a record whose values are number/string literals, or move the spread into a `'use client'` component so hydration computes it."
         }
       });
+      return null;
     }
-    const rawArray = this.convertExpressionToPerl(loop.array);
-    let sortedHoist = null;
-    let array = rawArray;
-    if (loop.sortComparator) {
-      sortedHoist = `bf_iter_${perlIdentifierFromMarkerId(loop.markerId)}`;
-      array = `$${sortedHoist}`;
-    }
-    const param = loop.param;
-    const indexVar = loop.iterationShape === "keys" ? `$${param}` : loop.index ? `$${loop.index}` : "$_i";
-    const loopBound = 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 renderedChildren = this.renderChildren(loop.children);
-    this.inLoop = prevInLoop;
-    const children = loop.bodyIsItemConditional && loop.key ? `<%== bf->comment("loop-i:" . ${this.convertExpressionToPerl(loop.key)}) %>
-${renderedChildren}` : renderedChildren;
-    const lines = [];
-    lines.push(`<%== bf->comment("loop:${loop.markerId}") %>`);
-    if (sortedHoist && loop.sortComparator) {
-      lines.push(`% my $${sortedHoist} = ${renderSortMethod(rawArray, loop.sortComparator)};`);
-    }
-    lines.push(`% for my ${indexVar} (0..$#{${array}}) {`);
-    if (loop.iterationShape !== "keys") {
-      if (supportableDestructure) {
-        lines.push(`% my $__bf_item = ${array}->[${indexVar}];`);
-        for (const b of loop.paramBindings ?? []) {
-          lines.push(b.rest ? `% my $${b.name} = $__bf_item;` : `% my $${b.name} = $__bf_item->{${b.path.slice(1)}};`);
-        }
-      } else {
-        lines.push(`% my $${param} = ${array}->[${indexVar}];`);
-      }
-    }
-    if (loop.filterPredicate) {
-      let filterCond;
-      if (loop.filterPredicate.blockBody) {
-        filterCond = this.renderBlockBodyCondition(loop.filterPredicate.blockBody, loop.filterPredicate.param);
-      } else if (loop.filterPredicate.predicate) {
-        filterCond = this.renderPerlFilterExpr(loop.filterPredicate.predicate, loop.filterPredicate.param);
-      } else {
-        filterCond = "1";
-      }
-      if (loop.filterPredicate.param !== param) {
-        filterCond = filterCond.replace(new RegExp(`\\$${loop.filterPredicate.param}\\b`, "g"), `$${param}`);
-      }
-      lines.push(`% if (${filterCond}) {`);
-      lines.push(children);
-      lines.push(`% }`);
-    } else {
-      lines.push(children);
-    }
-    for (const n of loopBound) {
-      const c = (this.loopBoundNames.get(n) ?? 1) - 1;
-      if (c <= 0)
-        this.loopBoundNames.delete(n);
-      else
-        this.loopBoundNames.set(n, c);
-    }
-    lines.push(`% }`);
-    lines.push(`<%== bf->comment("/loop:${loop.markerId}") %>`);
-    return lines.join(`
-`);
+    const valPerl = indexed !== null ? indexed : ctx.convertExpressionToPerl("", val);
+    entries.push(`'${key.replace(/'/g, "\\'")}' => ${valPerl}`);
   }
-  componentPropEmitter = {
-    emitLiteral: (value, name) => `${perlHashKey(name)} => '${value.value}'`,
-    emitExpression: (value, name) => {
-      if (value.parts) {
-        return `${perlHashKey(name)} => ${this.convertTemplateLiteralPartsToPerl(value.parts)}`;
-      }
-      return `${perlHashKey(name)} => ${this.convertExpressionToPerl(value.expr)}`;
-    },
-    emitSpread: (value) => {
-      const perlExpr = this.convertExpressionToPerl(value.expr);
-      return perlExpr.startsWith("%") ? perlExpr : `%{${perlExpr}}`;
-    },
-    emitTemplate: (value, name) => `${perlHashKey(name)} => ${this.convertTemplateLiteralPartsToPerl(value.parts)}`,
-    emitBooleanAttr: (_value, name) => `${perlHashKey(name)} => 1`,
-    emitBooleanShorthand: (_value, name) => `${perlHashKey(name)} => 1`,
-    emitJsxChildren: () => ""
-  };
-  renderComponent(comp) {
-    const propParts = [];
-    for (const p of comp.props) {
-      if ((p.name.match(/^on[A-Z]/) || p.name === "ref") && p.value.kind === "expression")
-        continue;
-      const lowered = emitAttrValue(p.value, this.componentPropEmitter, p.name);
-      if (lowered)
-        propParts.push(lowered);
-    }
-    if (comp.slotId && !this.inLoop) {
-      propParts.push(`_bf_slot => '${comp.slotId}'`);
-    }
-    const propsStr = propParts.length > 0 ? ", " + propParts.join(", ") : "";
-    const tplName = this.toTemplateName(comp.name);
-    const effectiveChildren = comp.children.length > 0 ? comp.children : resolveJsxChildrenProp(comp.props);
-    if (effectiveChildren.length > 0) {
-      const prevInLoop = this.inLoop;
-      this.inLoop = false;
-      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 entries.length === 0 ? "{}" : `{ ${entries.join(", ")} }`;
+}
+function isLiteralIndex(index) {
+  return index.kind === "literal" && (index.literalType === "number" || index.literalType === "string");
+}
+function recordIndexAccessToPerl(ctx, val) {
+  if (val.kind !== "index-access" || val.object.kind !== "identifier" || val.index.kind !== "identifier") {
+    return null;
+  }
+  const tsVal = ts.factory.createElementAccessExpression(ts.factory.createIdentifier(val.object.name), ts.factory.createIdentifier(val.index.name));
+  const parsed = parseRecordIndexAccess(tsVal, ctx.localConstants, ctx.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}}`;
+}
+
+// src/adapter/memo/seed.ts
+import {
+  collectContextConsumers,
+  computeSsrSeedPlan
+} from "@barefootjs/jsx";
+function contextDefaultPerl(c) {
+  const d = c.defaultValue;
+  if (d === null || d === undefined)
+    return "undef";
+  if (typeof d === "string")
+    return `'${d.replace(/[\\']/g, (m) => `\\${m}`)}'`;
+  if (typeof d === "boolean")
+    return d ? "1" : "0";
+  return String(d);
+}
+function generateContextConsumerSeed(ir) {
+  const consumers = collectContextConsumers(ir.metadata);
+  if (consumers.length === 0)
+    return "";
+  return consumers.map((c) => `% my $${c.localName} = bf->use_context('${c.contextName}', ${contextDefaultPerl(c)});`).join(`
+`) + `
+`;
+}
+function generateDerivedMemoSeed(ctx, ir) {
+  const plan = ir.metadata.ssrSeedPlan ?? computeSsrSeedPlan(ir.metadata);
+  const lines = [];
+  for (const step of plan.steps) {
+    if (step.kind !== "derived")
+      continue;
+    const perl = ctx.convertExpressionToPerl(step.expr, step.parsed);
+    if (perl === "" || !/\$[A-Za-z_]\w*/.test(perl))
+      continue;
+    lines.push(`% my $${step.name} = ${perl};`);
+  }
+  return lines.length > 0 ? lines.join(`
+`) + `
+` : "";
+}
+
+// src/adapter/value/parsed-literal.ts
+function isStringTypeInfo(type) {
+  return type?.kind === "primitive" && type.primitive === "string";
+}
+function isBareStringLiteral(initialValue) {
+  if (!initialValue)
+    return false;
+  const v = initialValue.trim();
+  return v.startsWith("'") && v.endsWith("'") || v.startsWith('"') && v.endsWith('"');
+}
+
+// src/adapter/props/prop-classes.ts
+function collectProviderDataNames(ir) {
+  return new Set([
+    ...ir.metadata.propsParams.map((p) => p.name),
+    ...(ir.metadata.signals ?? []).map((s) => s.getter),
+    ...(ir.metadata.memos ?? []).map((m) => m.name)
+  ]);
+}
+function collectBooleanTypedProps(ir) {
+  return new Set(ir.metadata.propsParams.filter((prop) => prop.type?.primitive === "boolean" || prop.type?.raw === "boolean").map((prop) => prop.name));
+}
+function collectNullableOptionalProps(ir) {
+  return new Set(ir.metadata.propsParams.filter((p) => p.defaultValue === undefined && !p.isRest && p.type?.kind !== "primitive").map((p) => p.name));
+}
+function collectStringValueNames(ir) {
+  const names = new Set;
+  for (const s of ir.metadata.signals) {
+    if (isStringTypeInfo(s.type) || isBareStringLiteral(s.initialValue)) {
+      names.add(s.getter);
     }
-    return `<%== bf->render_child('${tplName}'${propsStr}) %>`;
   }
-  childrenCaptureCounter = 0;
-  presenceVarCounter = 0;
-  toTemplateName(componentName) {
-    return componentName.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+  for (const p of ir.metadata.propsParams) {
+    if (isStringTypeInfo(p.type))
+      names.add(p.name);
   }
-  renderIfStatement(ifStmt) {
-    const condition = this.convertExpressionToPerl(ifStmt.condition);
-    const consequent = ifStmt.consequent.type === "if-statement" ? this.renderIfStatement(ifStmt.consequent) : this.renderNode(ifStmt.consequent);
-    let result = `% if (${condition}) {
-${consequent}
-`;
-    if (ifStmt.alternate) {
-      if (ifStmt.alternate.type === "if-statement") {
-        const altResult = this.renderIfStatement(ifStmt.alternate);
-        result += altResult.replace(/^% if/, "% } elsif");
-      } else {
-        const alternate = this.renderNode(ifStmt.alternate);
-        result += `% } else {
-${alternate}
+  return names;
+}
+
+// src/adapter/mojo-adapter.ts
+class MojoAdapter extends BaseAdapter {
+  name = "mojolicious";
+  extension = ".html.ep";
+  templatesPerComponent = true;
+  importMapInjection = "html-snippet";
+  templatePrimitives = MOJO_PRIMITIVE_EMIT_MAP;
+  componentName = "";
+  rootScopeNodes = new Set;
+  options;
+  errors = [];
+  inLoop = false;
+  propsObjectName = null;
+  propsParams = [];
+  booleanTypedProps = new Set;
+  providerDataNames = new Set;
+  stringValueNames = new Set;
+  _searchParamsLocals = new Set;
+  _loweringMatchers = [];
+  moduleStringConsts = new Map;
+  localConstants = [];
+  loopBoundNames = new Map;
+  nullableOptionalProps = new Set;
+  constructor(options = {}) {
+    super();
+    this.options = {
+      clientJsBasePath: options.clientJsBasePath ?? "/static/components/",
+      barefootJsPath: options.barefootJsPath ?? "/static/components/barefoot.js"
+    };
+  }
+  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.providerDataNames = collectProviderDataNames(ir);
+    this.booleanTypedProps = collectBooleanTypedProps(ir);
+    this.nullableOptionalProps = collectNullableOptionalProps(ir);
+    this.stringValueNames = collectStringValueNames(ir);
+    this.moduleStringConsts = collectModuleStringConsts(ir.metadata.localConstants);
+    this._searchParamsLocals = searchParamsLocalNames(ir.metadata);
+    this._loweringMatchers = prepareLoweringMatchers(ir.metadata);
+    this.localConstants = ir.metadata.localConstants ?? [];
+    this.loopBoundNames.clear();
+    this.errors = [];
+    this.childrenCaptureCounter = 0;
+    if (!options?.siblingTemplatesRegistered) {
+      this.errors.push(...collectImportedLoopChildComponentErrors(ir, this.componentName));
+    }
+    this.rootScopeNodes = collectRootScopeNodes(ir.root);
+    const templateBody = ir.root.type === "if-statement" ? this.renderIfStatement(ir.root) : this.renderNode(ir.root);
+    const scriptReg = options?.skipScriptRegistration ? "" : this.generateScriptRegistrations(ir, options?.scriptBaseName);
+    const ctxSeed = generateContextConsumerSeed(ir);
+    const memoSeed = generateDerivedMemoSeed(this.memoCtx, ir);
+    const template = `${scriptReg}${ctxSeed}${memoSeed}${templateBody}
 `;
-      }
+    if (this.errors.length > 0) {
+      ir.errors.push(...this.errors);
     }
-    result += `% }`;
-    return result;
+    const sections = {
+      imports: "",
+      types: "",
+      component: template,
+      defaultExport: ""
+    };
+    return {
+      template,
+      sections,
+      extension: this.extension
+    };
   }
-  renderFragment(fragment) {
-    const children = this.renderChildren(fragment.children);
-    if (fragment.needsScopeComment) {
-      return `<%== bf->scope_comment %>${children}`;
+  isBooleanTypedPropRef(expr) {
+    let bare = expr.trim();
+    if (this.propsObjectName && bare.startsWith(`${this.propsObjectName}.`)) {
+      bare = bare.slice(this.propsObjectName.length + 1);
     }
-    return children;
+    if (!/^[A-Za-z_$][\w$]*$/.test(bare))
+      return false;
+    return this.booleanTypedProps.has(bare);
   }
-  renderSlot(_slot) {
-    return `<%= content %>`;
+  parseUndefinedAlternateTernary(expr) {
+    const parsed = parseExpression2(expr.trim());
+    if (parsed?.kind !== "conditional")
+      return null;
+    const alt = parsed.alternate;
+    const isUndef = alt.kind === "identifier" && (alt.name === "undefined" || alt.name === "null") || alt.kind === "literal" && (alt.value === null || alt.value === undefined);
+    if (!isUndef)
+      return null;
+    return {
+      condition: exprToString(parsed.test),
+      consequent: exprToString(parsed.consequent)
+    };
   }
-  renderAsync(node) {
-    const fallback = this.renderNode(node.fallback);
-    const children = this.renderChildren(node.children);
-    const fallbackVar = `$bf_async_fallback_${node.id}`;
-    return `<% my ${fallbackVar} = begin %>${fallback}<% end %><%== bf->async_boundary('${node.id}', ${fallbackVar}) %>
-${children}`;
+  resolveLiteralConst(name) {
+    if (this.loopBoundNames?.has?.(name))
+      return null;
+    const c = (this.localConstants ?? []).find((lc) => lc.name === name);
+    if (c?.value === undefined)
+      return null;
+    const v = c.value.trim();
+    if (/^-?\d+(\.\d+)?$/.test(v))
+      return v;
+    const strLit = /^'([^'\\]*)'$/.exec(v) ?? /^"([^"\\]*)"$/.exec(v);
+    if (strLit)
+      return `'${strLit[1].replace(/[\\']/g, (m) => `\\${m}`)}'`;
+    return null;
   }
-  elementAttrEmitter = {
-    emitLiteral: (value, name) => `${name}="${value.value}"`,
-    emitExpression: (value, name) => {
-      if (name === "style") {
-        const css = this.tryLowerStyleObject(value.expr);
-        if (css !== null)
-          return `style="${css}"`;
-      }
-      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) || this.isBooleanTypedPropRef(value.expr) ? `${name}="<%= bf->bool_str(${perl2}) %>"` : `${name}="<%= ${perl2} %>"`;
-        return `<% if (defined ${perl2}) { %>${body}<% } %>`;
-      }
-      if (isBooleanAttr(name)) {
-        return `<%= ${this.convertExpressionToPerl(value.expr)} ? '${name}' : '' %>`;
-      }
-      if (value.presenceOrUndefined) {
-        const perl2 = this.convertExpressionToPerl(value.expr);
-        const tmp = `$bf_pu${this.presenceVarCounter++}`;
-        const body = isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name) || this.isBooleanTypedPropRef(value.expr) ? `${name}="<%= bf->bool_str(${tmp}) %>"` : `${name}="<%= ${tmp} %>"`;
-        return `<% my ${tmp} = ${perl2}; if (${tmp}) { %>${body}<% } %>`;
-      }
-      {
-        const m = this.parseUndefinedAlternateTernary(value.expr);
-        if (m) {
-          const cond = this.convertExpressionToPerl(m.condition);
-          const val = this.convertExpressionToPerl(m.consequent);
-          return `<% if (${cond}) { %>${name}="<%= ${val} %>"<% } %>`;
-        }
-      }
-      const perl = this.convertExpressionToPerl(value.expr);
-      if (isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name) || this.isBooleanTypedPropRef(value.expr)) {
-        return `${name}="<%= bf->bool_str(${perl}) %>"`;
-      }
-      return `${name}="<%= ${perl} %>"`;
-    },
-    emitBooleanAttr: (_value, name) => name,
-    emitTemplate: (value, name) => `${name}="<%= ${this.convertTemplateLiteralPartsToPerl(value.parts)} %>"`,
-    emitSpread: (value) => {
-      if (this.refuseUnsupportedAttrExpression(value.expr, "...")) {
-        return "";
-      }
-      const trimmed = value.expr.trim();
-      if (this.propsObjectName && this.propsObjectName === trimmed) {
-        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}) %>`;
-    },
-    emitBooleanShorthand: () => "",
-    emitJsxChildren: () => ""
-  };
-  tryLowerStyleObject(expr) {
-    const entries = parseStyleObjectEntries(expr);
-    if (!entries)
+  resolveStaticRecordLiteral(objectName, key) {
+    if (this.loopBoundNames?.has?.(objectName))
       return null;
-    for (const e of entries) {
-      if (e.kind === "expr" && !isSupported(parseExpression2(e.expr)).supported)
-        return null;
-    }
-    return entries.map((e) => e.kind === "literal" ? `${this.escapeAttrText(e.cssKey)}:${this.escapeAttrText(e.value)}` : `${this.escapeAttrText(e.cssKey)}:<%= ${this.convertExpressionToPerl(e.expr)} %>`).join(";");
+    const hit = lookupStaticRecordLiteral(objectName, key, this.localConstants);
+    if (!hit)
+      return null;
+    return hit.kind === "number" ? hit.text : `'${hit.text.replace(/[\\']/g, (m) => `\\${m}`)}'`;
   }
-  escapeAttrText(s) {
-    return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  resolveModuleStringConst(name) {
+    if (this.loopBoundNames.has(name))
+      return null;
+    const value = this.moduleStringConsts.get(name);
+    if (value === undefined)
+      return null;
+    return `'${value.replace(/[\\']/g, (m) => `\\${m}`)}'`;
   }
-  renderAttributes(element) {
-    const parts = [];
-    for (const attr of element.attrs) {
-      if (attr.clientOnly)
-        continue;
-      let attrName;
-      if (attr.name === "className")
-        attrName = "class";
-      else if (attr.name === "key")
-        attrName = "data-key";
-      else
-        attrName = attr.name;
-      const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, attrName);
-      if (lowered)
-        parts.push(lowered);
-    }
-    return parts.length > 0 ? " " + parts.join(" ") : "";
+  generateScriptRegistrations(ir, scriptBaseName) {
+    const hasInteractivity = hasClientInteractivity(ir);
+    if (!hasInteractivity)
+      return "";
+    const name = scriptBaseName ?? ir.metadata.componentName;
+    const runtimePath = this.options.barefootJsPath;
+    const clientJsPath = `${this.options.clientJsBasePath}${name}.client.js`;
+    const lines = [];
+    lines.push(`% bf->register_script('${runtimePath}');`);
+    lines.push(`% bf->register_script('${clientJsPath}');`);
+    lines.push("");
+    return lines.join(`
+`);
   }
-  renderScopeMarker(_instanceIdExpr) {
-    return `bf-s="<%= bf->scope_attr %>" <%== bf->hydration_attrs %> <%== bf->props_attr %>`;
+  renderNode(node) {
+    return emitIRNode(node, this, {});
   }
-  renderSlotMarker(slotId) {
-    return `${BF_SLOT}="${slotId}"`;
+  emitElement(node, _ctx, _emit) {
+    return this.renderElement(node);
   }
-  renderCondMarker(condId) {
-    return `${BF_COND}="${condId}"`;
+  emitText(node) {
+    return node.value;
   }
-  renderPerlFilterExpr(expr, param, localVarMap = new Map) {
-    return emitParsedExpr(expr, new MojoFilterEmitter(param, localVarMap, (n) => this._isStringValueName(n)));
+  emitExpression(node) {
+    return this.renderExpression(node);
   }
-  renderBlockBodyCondition(statements, param) {
-    const localVarMap = new Map;
-    const paths = this.collectReturnPaths(statements, [], localVarMap, param);
-    if (paths.length === 0)
-      return "1";
-    if (paths.length === 1)
-      return this.buildSinglePathCondition(paths[0], param, localVarMap);
-    const parts = [];
-    for (const path of paths) {
-      if (path.result.kind === "literal" && path.result.literalType === "boolean" && path.result.value === false)
-        continue;
-      const cond = this.buildSinglePathCondition(path, param, localVarMap);
-      if (cond !== "0")
-        parts.push(cond);
-    }
-    if (parts.length === 0)
-      return "0";
-    if (parts.length === 1)
-      return parts[0];
-    return `(${parts.join(" || ")})`;
-  }
-  collectReturnPaths(statements, currentConditions, localVarMap, param) {
-    const paths = [];
-    for (const stmt of statements) {
-      if (stmt.kind === "var-decl") {
-        if (stmt.init.kind === "call" && stmt.init.callee.kind === "identifier") {
-          localVarMap.set(stmt.name, stmt.init.callee.name);
-        }
-      } else if (stmt.kind === "return") {
-        paths.push({ conditions: [...currentConditions], result: stmt.value });
-        break;
-      } else if (stmt.kind === "if") {
-        const thenPaths = this.collectReturnPaths(stmt.consequent, [...currentConditions, stmt.condition], localVarMap, param);
-        paths.push(...thenPaths);
-        if (stmt.alternate) {
-          const negated = { kind: "unary", op: "!", argument: stmt.condition };
-          const elsePaths = this.collectReturnPaths(stmt.alternate, [...currentConditions, negated], localVarMap, param);
-          paths.push(...elsePaths);
-        } else {
-          currentConditions.push({ kind: "unary", op: "!", argument: stmt.condition });
-        }
-      }
-    }
-    return paths;
+  emitConditional(node, _ctx, _emit) {
+    return this.renderConditional(node);
   }
-  buildSinglePathCondition(path, param, localVarMap) {
-    if (path.result.kind === "literal" && path.result.literalType === "boolean") {
-      if (path.result.value === true) {
-        if (path.conditions.length === 0)
-          return "1";
-        return this.renderConditionsAnd(path.conditions, param, localVarMap);
-      }
-      return "0";
-    }
-    if (path.conditions.length === 0) {
-      return this.renderPerlFilterExpr(path.result, param, localVarMap);
-    }
-    const condPart = this.renderConditionsAnd(path.conditions, param, localVarMap);
-    const resultPart = this.renderPerlFilterExpr(path.result, param, localVarMap);
-    return `(${condPart} && ${resultPart})`;
+  emitLoop(node, _ctx, _emit) {
+    return this.renderLoop(node);
   }
-  renderConditionsAnd(conditions, param, localVarMap) {
-    if (conditions.length === 0)
-      return "1";
-    if (conditions.length === 1)
-      return this.renderPerlFilterExpr(conditions[0], param, localVarMap);
-    const parts = conditions.map((c) => this.renderPerlFilterExpr(c, param, localVarMap));
-    return `(${parts.join(" && ")})`;
+  emitComponent(node, _ctx, _emit) {
+    return this.renderComponent(node);
   }
-  convertTemplateLiteralPartsToPerl(literalParts) {
-    const parts = [];
-    for (const part of literalParts) {
-      if (part.type === "string") {
-        parts.push(this.substituteJsInterpolationsToPerl(part.value));
-      } else if (part.type === "ternary") {
-        const cond = this.convertExpressionToPerl(part.condition);
-        parts.push(`(${cond} ? '${part.whenTrue}' : '${part.whenFalse}')`);
-      } else if (part.type === "lookup") {
-        const keyExpr = this.convertExpressionToPerl(part.key);
-        const entries = Object.entries(part.cases).map(([k, v]) => `'${k}' => '${v}'`).join(", ");
-        parts.push(`({ ${entries} }->{${keyExpr}} // '')`);
-      }
-    }
-    return parts.length === 1 ? parts[0] : parts.join(" . ");
+  emitFragment(node, _ctx, _emit) {
+    return this.renderFragment(node);
   }
-  substituteJsInterpolationsToPerl(s) {
-    const segments = [];
-    const re = /\$\{([^}]+)\}/g;
-    let lastIndex = 0;
-    let m;
-    while ((m = re.exec(s)) !== null) {
-      if (m.index > lastIndex) {
-        segments.push(`'${s.slice(lastIndex, m.index)}'`);
-      }
-      segments.push(this.convertExpressionToPerl(m[1].trim()));
-      lastIndex = re.lastIndex;
-    }
-    if (lastIndex < s.length) {
-      segments.push(`'${s.slice(lastIndex)}'`);
-    }
-    if (segments.length === 0)
-      return `''`;
-    return segments.length === 1 ? segments[0] : `(${segments.join(" . ")})`;
+  emitSlot(node) {
+    return this.renderSlot(node);
   }
-  refuseUnsupportedAttrExpression(expr, attrName) {
-    let probe = expr.trim();
-    while (probe.startsWith("("))
-      probe = probe.slice(1).trimStart();
-    const startsAsObjectLiteral = probe.startsWith("{");
-    const hasTaggedTemplate = /[A-Za-z_$][\w$]*\s*`/.test(probe);
-    if (!startsAsObjectLiteral && !hasTaggedTemplate)
-      return false;
-    const parsed = parseExpression2(expr.trim());
-    const support = isSupported(parsed);
-    if (parsed.kind !== "unsupported" && support.supported)
-      return false;
-    const reason = support.reason ?? (parsed.kind === "unsupported" ? parsed.reason : undefined);
-    const reasonLine = reason ? `
-${reason}` : "";
-    this.errors.push({
-      code: "BF101",
-      severity: "error",
-      message: `Expression not supported on attribute '${attrName}': ${expr.trim()}${reasonLine}`,
-      loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
-      suggestion: {
-        message: "The Mojo adapter cannot lower JS object literals or tagged-template-literal expressions into Embedded Perl. Move the expression into a `'use client'` component (so hydration computes it), or expand it into discrete attributes whose values are values the adapter can lower."
-      }
-    });
-    return true;
+  emitIfStatement(node, _ctx, _emit) {
+    return this.renderIfStatement(node);
   }
-  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}`;
+  emitProvider(node, _ctx, _emit) {
+    const value = this.providerValuePerl(node.valueProp);
+    const children = this.renderChildren(node.children);
+    const name = node.contextName;
+    return `<% bf->provide_context('${name}', ${value}); %>` + children + `<% bf->revoke_context('${name}'); %>`;
   }
-  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);
-      if (indexed === null && ts.isElementAccessExpression(initNode) && initNode.argumentExpression && !ts.isNumericLiteral(initNode.argumentExpression) && !ts.isStringLiteral(initNode.argumentExpression)) {
-        this.errors.push({
-          code: "BF101",
-          severity: "error",
-          message: `Spread object value '${initNode.getText(sf)}' indexes a record map whose values aren't scalar literals — it can't lower to an inline Perl hashref.`,
-          loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
-          suggestion: {
-            message: "Index a record whose values are number/string literals, or move the spread into a `'use client'` component so hydration computes it."
-          }
-        });
-        return null;
-      }
-      const valPerl = indexed !== null ? indexed : this.convertExpressionToPerl(prop.initializer.getText(sf));
-      entries.push(`'${key.replace(/'/g, "\\'")}' => ${valPerl}`);
+  providerValuePerl(valueProp) {
+    const v = valueProp.value;
+    if (v.kind === "literal") {
+      return typeof v.value === "string" ? `'${v.value.replace(/[\\']/g, (m) => `\\${m}`)}'` : String(v.value);
+    }
+    if (v.kind === "expression") {
+      const hashref = this.providerObjectLiteralPerl(v.expr);
+      if (hashref !== null)
+        return hashref;
+      return this.convertExpressionToPerl(v.expr);
     }
-    return entries.length === 0 ? "{}" : `{ ${entries.join(", ")} }`;
+    if (v.kind === "template")
+      return this.convertTemplateLiteralPartsToPerl(v.parts);
+    return "undef";
   }
-  recordIndexAccessToPerl(val) {
-    const parsed = parseRecordIndexAccess(val, this.localConstants, this.propsParams);
-    if (!parsed)
+  providerObjectLiteralPerl(expr) {
+    const members = parseProviderObjectLiteral(expr.trim());
+    if (members === null)
       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}`;
+    const entries = members.map((m) => {
+      const key = `'${m.name.replace(/[\\']/g, (c) => `\\${c}`)}'`;
+      if (m.kind === "function" || /^on[A-Z]/.test(m.name))
+        return `${key} => undef`;
+      const src = m.kind === "getter" ? m.body : m.expr;
+      if (this.isClientOnlyContextIdentifier(src))
+        return `${key} => undef`;
+      return `${key} => ${this.convertExpressionToPerl(src)}`;
     });
-    return `{ ${entries.join(", ")} }->{$${parsed.indexPropName}}`;
-  }
-  convertExpressionToPerl(expr) {
-    const trimmed = expr.trim();
-    if (trimmed === "")
-      return "''";
-    const parsed = parseExpression2(trimmed);
-    const support = isSupported(parsed);
-    if (!support.supported) {
-      this.errors.push({
-        code: "BF101",
-        severity: "error",
-        message: `Expression not supported: ${trimmed}`,
-        loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
-        suggestion: {
-          message: support.reason ? `${support.reason}
-
-Options:
-1. Use /* @client */ for client-side evaluation
-2. Pre-compute the value in Perl` : `Options:
-1. Use /* @client */ for client-side evaluation
-2. Pre-compute the value in Perl`
-        }
-      });
-      return "''";
-    }
-    return this.renderParsedExprToPerl(parsed);
-  }
-  renderParsedExprToPerl(expr) {
-    return emitParsedExpr(expr, new MojoTopLevelEmitter(this));
-  }
-  _isStringValueName(name) {
-    return this.stringValueNames.has(name);
+    return `{ ${entries.join(", ")} }`;
   }
-  _recordExprBF101(message, reason) {
-    this.errors.push({
-      code: "BF101",
-      severity: "error",
-      message,
-      loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
-      suggestion: {
-        message: reason ? `${reason}
-
-Options:
-1. Use /* @client */ for client-side evaluation
-2. Pre-compute the value in Perl` : `Options:
-1. Use /* @client */ for client-side evaluation
-2. Pre-compute the value in Perl`
-      }
-    });
+  isClientOnlyContextIdentifier(src) {
+    const t = src.trim();
+    if (!/^[A-Za-z_$][\w$]*$/.test(t))
+      return false;
+    return !this.providerDataNames.has(t) && !this.moduleStringConsts.has(t);
   }
-  _renderPerlFilterExprPublic(expr, param) {
-    return this.renderPerlFilterExpr(expr, param);
+  emitAsync(node, _ctx, _emit) {
+    return this.renderAsync(node);
   }
-}
-function renderArrayMethod(method, object, args, emit) {
-  switch (method) {
-    case "join": {
-      const obj = emit(object);
-      const sep = args.length >= 1 ? emit(args[0]) : `','`;
-      return `join(${sep}, @{${obj}})`;
+  renderElement(element) {
+    const tag = element.tag;
+    const attrs = this.renderAttributes(element);
+    const children = this.renderChildren(element.children);
+    let hydrationAttrs = "";
+    if (element.needsScope) {
+      hydrationAttrs += ` ${this.renderScopeMarker("")}`;
     }
-    case "includes": {
-      const obj = emit(object);
-      const needle = emit(args[0]);
-      return `bf->includes(${obj}, ${needle})`;
+    if (this.rootScopeNodes.has(element) && element.needsScope) {
+      hydrationAttrs += ` <%== bf->data_key_attr %>`;
     }
-    case "indexOf":
-    case "lastIndexOf": {
-      const fn = method === "indexOf" ? "index_of" : "last_index_of";
-      const obj = emit(object);
-      const needle = emit(args[0]);
-      return `bf->${fn}(${obj}, ${needle})`;
+    if (element.slotId) {
+      hydrationAttrs += ` ${this.renderSlotMarker(element.slotId)}`;
     }
-    case "at": {
-      const obj = emit(object);
-      const idx = args.length >= 1 ? emit(args[0]) : "0";
-      return `bf->at(${obj}, ${idx})`;
+    if (element.regionId) {
+      hydrationAttrs += ` ${BF_REGION}="${element.regionId}"`;
     }
-    case "concat": {
-      if (args.length === 0) {
-        return emit(object);
+    const voidElements = [
+      "area",
+      "base",
+      "br",
+      "col",
+      "embed",
+      "hr",
+      "img",
+      "input",
+      "link",
+      "meta",
+      "param",
+      "source",
+      "track",
+      "wbr"
+    ];
+    if (voidElements.includes(tag.toLowerCase())) {
+      return `<${tag}${attrs}${hydrationAttrs}>`;
+    }
+    return `<${tag}${attrs}${hydrationAttrs}>${children}</${tag}>`;
+  }
+  renderExpression(expr) {
+    if (expr.clientOnly) {
+      if (expr.slotId) {
+        return `<%== bf->comment("client:${expr.slotId}") %>`;
       }
-      const a = emit(object);
-      const b = emit(args[0]);
-      return `bf->concat(${a}, ${b})`;
+      return "";
     }
-    case "slice": {
-      const recv = emit(object);
-      const start = args.length >= 1 ? emit(args[0]) : "0";
-      const end = args.length >= 2 ? emit(args[1]) : "undef";
-      return `bf->slice(${recv}, ${start}, ${end})`;
+    const perlExpr = this.convertExpressionToPerl(expr.expr);
+    if (expr.slotId) {
+      return `<%== bf->text_start("${expr.slotId}") %><%= ${perlExpr} %><%== bf->text_end %>`;
     }
-    case "reverse":
-    case "toReversed": {
-      const recv = emit(object);
-      return `bf->reverse(${recv})`;
+    return `<%= ${perlExpr} %>`;
+  }
+  renderConditional(cond) {
+    if (cond.clientOnly && cond.slotId) {
+      return `<%== bf->comment("cond-start:${cond.slotId}") %><%== bf->comment("cond-end:${cond.slotId}") %>`;
     }
-    case "toLowerCase": {
-      const recv = emit(object);
-      return `lc(${recv})`;
+    const condition = this.convertExpressionToPerl(cond.condition);
+    const whenTrue = this.renderNode(cond.whenTrue);
+    const whenFalse = this.renderNodeOrNull(cond.whenFalse);
+    const isFragmentBranch = cond.whenTrue.type === "fragment" || cond.whenFalse.type === "fragment";
+    const useCommentMarkers = cond.slotId && isFragmentBranch;
+    let markedTrue = whenTrue;
+    let markedFalse = whenFalse;
+    if (cond.slotId && !useCommentMarkers) {
+      markedTrue = this.addCondMarkerToFirstElement(whenTrue, cond.slotId);
+      markedFalse = whenFalse ? this.addCondMarkerToFirstElement(whenFalse, cond.slotId) : whenFalse;
     }
-    case "toUpperCase": {
-      const recv = emit(object);
-      return `uc(${recv})`;
+    let result;
+    if (useCommentMarkers) {
+      const inner = whenFalse ? `
+% if (${condition}) {
+${whenTrue}
+% } else {
+${whenFalse}
+% }
+` : `
+% if (${condition}) {
+${whenTrue}
+% }
+`;
+      result = `<%== bf->comment("cond-start:${cond.slotId}") %>${inner}<%== bf->comment("cond-end:${cond.slotId}") %>`;
+    } else if (markedFalse) {
+      result = `
+% if (${condition}) {
+${markedTrue}
+% } else {
+${markedFalse}
+% }
+`;
+    } else if (cond.slotId) {
+      result = `<%== bf->comment("cond-start:${cond.slotId}") %>
+% if (${condition}) {
+${whenTrue}
+% }
+<%== bf->comment("cond-end:${cond.slotId}") %>`;
+    } else {
+      result = `
+% if (${condition}) {
+${whenTrue}
+% }
+`;
     }
-    case "trim": {
-      const recv = emit(object);
-      return `bf->trim(${recv})`;
+    return result;
+  }
+  renderNodeOrNull(node) {
+    if (node.type === "expression" && (node.expr === "null" || node.expr === "undefined")) {
+      return null;
     }
-    case "toFixed": {
-      const recv = emit(object);
-      const digits = args.length >= 1 ? emit(args[0]) : "0";
-      return `bf->to_fixed(${recv}, ${digits})`;
+    return this.renderNode(node);
+  }
+  addCondMarkerToFirstElement(content, condId) {
+    const match = content.match(/^(<\w+)([\s>])/);
+    if (match) {
+      return content.replace(/^(<\w+)([\s>])/, `$1 ${BF_COND}="${condId}"$2`);
     }
-    case "split": {
-      const recv = emit(object);
-      if (args.length === 0) {
-        return `bf->split(${recv})`;
-      }
-      const sep = emit(args[0]);
-      if (args.length === 1) {
-        return `bf->split(${recv}, ${sep})`;
-      }
-      const limit = emit(args[1]);
-      return `bf->split(${recv}, ${sep}, ${limit})`;
+    return `<%== bf->comment("cond-start:${condId}") %>${content}<%== bf->comment("cond-end:${condId}") %>`;
+  }
+  renderLoop(loop) {
+    if (loop.clientOnly) {
+      return `<%== bf->comment("loop:${loop.markerId}") %><%== bf->comment("/loop:${loop.markerId}") %>`;
     }
-    case "startsWith":
-    case "endsWith": {
-      const fn = method === "startsWith" ? "starts_with" : "ends_with";
-      const recv = emit(object);
-      const arg = emit(args[0]);
-      if (args.length >= 2) {
-        return `bf->${fn}(${recv}, ${arg}, ${emit(args[1])})`;
-      }
-      return `bf->${fn}(${recv}, ${arg})`;
+    const destructure = !!(loop.paramBindings && loop.paramBindings.length > 0);
+    const supportableDestructure = destructure && isLowerableObjectRestDestructure(loop);
+    if (destructure && !supportableDestructure) {
+      this.errors.push({
+        code: "BF104",
+        severity: "error",
+        message: `Loop callback uses an array/object destructure pattern (\`${loop.param}\`) that the Mojo adapter cannot lower — Perl scalar bindings can't unpack a tuple in a single \`my\` declaration.`,
+        loc: loop.loc ?? { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+        suggestion: {
+          message: `Options:
+` + `  1. Rename the parameter to a single name and access tuple elements with index syntax in the body (e.g. \`entry => entry->[0]\` instead of \`([k, v]) => ...\`).
+` + `  2. Mark the loop position as @client-only so the destructure runs in JS on the client.
+` + `  3. Move the loop into a primitive that the adapter registers explicitly.`
+        }
+      });
     }
-    case "replace": {
-      const recv = emit(object);
-      const oldS = emit(args[0]);
-      const newS = emit(args[1]);
-      return `bf->replace(${recv}, ${oldS}, ${newS})`;
+    const rawArray = this.convertExpressionToPerl(loop.array);
+    let sortedHoist = null;
+    let array = rawArray;
+    if (loop.sortComparator) {
+      sortedHoist = `bf_iter_${perlIdentifierFromMarkerId(loop.markerId)}`;
+      array = `$${sortedHoist}`;
     }
-    case "repeat": {
-      const recv = emit(object);
-      const count = args.length === 0 ? "0" : emit(args[0]);
-      return `bf->repeat(${recv}, ${count})`;
+    const param = loop.param;
+    const indexVar = loop.iterationShape === "keys" ? `$${param}` : loop.index ? `$${loop.index}` : "$_i";
+    const loopBound = 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);
     }
-    case "padStart":
-    case "padEnd": {
-      const fn = method === "padStart" ? "pad_start" : "pad_end";
-      const recv = emit(object);
-      if (args.length === 0) {
-        return `bf->${fn}(${recv}, 0)`;
+    const prevInLoop = this.inLoop;
+    this.inLoop = true;
+    const renderedChildren = this.renderChildren(loop.children);
+    this.inLoop = prevInLoop;
+    const children = loop.bodyIsItemConditional && loop.key ? `<%== bf->comment("loop-i:" . ${this.convertExpressionToPerl(loop.key)}) %>
+${renderedChildren}` : renderedChildren;
+    const lines = [];
+    lines.push(`<%== bf->comment("loop:${loop.markerId}") %>`);
+    if (sortedHoist && loop.sortComparator) {
+      for (const n of loopBound) {
+        const c = (this.loopBoundNames.get(n) ?? 1) - 1;
+        if (c <= 0)
+          this.loopBoundNames.delete(n);
+        else
+          this.loopBoundNames.set(n, c);
       }
-      const target = emit(args[0]);
-      if (args.length === 1) {
-        return `bf->${fn}(${recv}, ${target})`;
+      const sortEmit = (e) => this.convertExpressionToPerl("", e);
+      const sortArrow = loop.sortComparator.arrow;
+      let sorted = null;
+      if (sortArrow.kind === "arrow") {
+        sorted = renderSortEval(rawArray, sortArrow.body, sortArrow.params, sortEmit);
       }
-      const pad = emit(args[1]);
-      return `bf->${fn}(${recv}, ${target}, ${pad})`;
-    }
-    default: {
-      const _exhaustive = method;
-      throw new Error(`renderArrayMethod: unhandled ArrayMethod '${_exhaustive}'`);
+      if (sorted === null) {
+        const structured = sortComparatorFromArrow2(sortArrow);
+        if (structured !== null)
+          sorted = renderSortMethod(rawArray, structured);
+      }
+      if (sorted === null) {
+        this._recordExprBF101(`.sort(...) loop comparator is not lowerable to a template sort`, `Pre-sort the array in the route handler, or mark the loop @client-only.`);
+        sorted = rawArray;
+      }
+      for (const n of loopBound) {
+        this.loopBoundNames.set(n, (this.loopBoundNames.get(n) ?? 0) + 1);
+      }
+      lines.push(`% my $${sortedHoist} = ${sorted};`);
     }
-  }
-}
-function perlIdentifierFromMarkerId(markerId) {
-  return markerId.replace(/[^a-zA-Z0-9]/g, (ch) => ch === "_" ? "__" : `_x${ch.charCodeAt(0).toString(16)}`);
-}
-function renderSortMethod(recv, c) {
-  const keyHashes = c.keys.map((k) => {
-    const keyEntry = k.key.kind === "self" ? `key_kind => 'self'` : `key_kind => 'field', key => '${k.key.field}'`;
-    return `{ ${keyEntry}, compare_type => '${k.type}', direction => '${k.direction}' }`;
-  });
-  return `bf->sort(${recv}, { keys => [${keyHashes.join(", ")}] })`;
-}
-function renderReduceMethod(recv, op, direction) {
-  const keyEntry = op.key.kind === "self" ? `key_kind => 'self'` : `key_kind => 'field', key => '${op.key.field}'`;
-  const init = op.type === "string" ? `'${op.init.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'` : op.init;
-  return `bf->reduce(${recv}, { op => '${op.op}', ${keyEntry}, type => '${op.type}', init => ${init}, direction => '${direction}' })`;
-}
-function renderFlatMethod(recv, depth) {
-  const d = depth === "infinity" ? -1 : depth;
-  return `bf->flat(${recv}, ${d})`;
-}
-function renderFlatMapMethod(recv, op) {
-  const proj = op.projection;
-  if (proj.kind === "tuple") {
-    const specs = proj.elements.map((l) => l.kind === "self" ? `['self', '']` : `['field', '${l.field}']`).join(", ");
-    return `bf->flat_map_tuple(${recv}, ${specs})`;
-  }
-  if (proj.kind === "self")
-    return `bf->flat_map(${recv}, 'self', '')`;
-  return `bf->flat_map(${recv}, 'field', '${proj.field}')`;
-}
-function isStringTypeInfo(type) {
-  return type?.kind === "primitive" && type.primitive === "string";
-}
-function isBareStringLiteral(initialValue) {
-  if (!initialValue)
-    return false;
-  const v = initialValue.trim();
-  return v.startsWith("'") && v.endsWith("'") || v.startsWith('"') && v.endsWith('"');
-}
-function isStringTypedOperand(expr, isStringName) {
-  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;
-}
-function emitIndexAccessPerl(object, index, emit, isStringName) {
-  const i = emit(index);
-  return isStringTypedOperand(index, isStringName) ? `${emit(object)}->{${i}}` : `${emit(object)}->[${i}]`;
-}
-
-class MojoFilterEmitter {
-  param;
-  localVarMap;
-  isStringName;
-  constructor(param, localVarMap, isStringName = () => false) {
-    this.param = param;
-    this.localVarMap = localVarMap;
-    this.isStringName = isStringName;
-  }
-  identifier(name) {
-    if (name === this.param)
-      return `$${this.param}`;
-    const signal = this.localVarMap.get(name);
-    if (signal)
-      return `$${signal}`;
-    return `$${name}`;
-  }
-  literal(value, literalType) {
-    if (literalType === "string")
-      return `'${value}'`;
-    if (literalType === "boolean")
-      return value ? "1" : "0";
-    if (literalType === "null")
-      return "undef";
-    return String(value);
-  }
-  member(object, property, _computed, emit) {
-    if (property === "length" && (object.kind === "higher-order" || object.kind === "array-literal")) {
-      return `scalar(@{${emit(object)}})`;
+    lines.push(`% for my ${indexVar} (0..$#{${array}}) {`);
+    if (loop.iterationShape !== "keys") {
+      if (supportableDestructure) {
+        lines.push(`% my $__bf_item = ${array}->[${indexVar}];`);
+        for (const b of loop.paramBindings ?? []) {
+          lines.push(b.rest ? `% my $${b.name} = $__bf_item;` : `% my $${b.name} = $__bf_item->{${b.path.slice(1)}};`);
+        }
+      } else {
+        lines.push(`% my $${param} = ${array}->[${indexVar}];`);
+      }
     }
-    return `${emit(object)}->{${property}}`;
-  }
-  indexAccess(object, index, emit) {
-    return emitIndexAccessPerl(object, index, emit, this.isStringName);
-  }
-  call(callee, args, emit) {
-    if (callee.kind === "identifier" && args.length === 0) {
-      return `$${callee.name}`;
+    if (loop.filterPredicate) {
+      let filterCond;
+      if (loop.filterPredicate.predicate) {
+        filterCond = this.renderPerlFilterExpr(loop.filterPredicate.predicate, loop.filterPredicate.param);
+      } else {
+        filterCond = "1";
+      }
+      if (loop.filterPredicate.param !== param) {
+        filterCond = filterCond.replace(new RegExp(`\\$${loop.filterPredicate.param}\\b`, "g"), `$${param}`);
+      }
+      lines.push(`% if (${filterCond}) {`);
+      lines.push(children);
+      lines.push(`% }`);
+    } else {
+      lines.push(children);
     }
-    return emit(callee);
-  }
-  unary(op, argument, emit) {
-    const arg = emit(argument);
-    if (op === "!") {
-      const needsParens = argument.kind === "binary" || argument.kind === "logical";
-      return needsParens ? `!(${arg})` : `!${arg}`;
+    for (const n of loopBound) {
+      const c = (this.loopBoundNames.get(n) ?? 1) - 1;
+      if (c <= 0)
+        this.loopBoundNames.delete(n);
+      else
+        this.loopBoundNames.set(n, c);
     }
-    if (op === "-")
-      return `-${arg}`;
-    return arg;
+    lines.push(`% }`);
+    lines.push(`<%== bf->comment("/loop:${loop.markerId}") %>`);
+    return lines.join(`
+`);
   }
-  binary(op, left, right, emit) {
-    const l = emit(left);
-    const r = emit(right);
-    const isStr = (e) => isStringTypedOperand(e, this.isStringName);
-    const stringCmp = isStr(left) || isStr(right);
-    if ((op === "===" || op === "==") && stringCmp) {
-      return `${l} eq ${r}`;
+  componentPropEmitter = {
+    emitLiteral: (value, name) => `${perlHashKey(name)} => '${value.value}'`,
+    emitExpression: (value, name) => {
+      if (value.parts) {
+        return `${perlHashKey(name)} => ${this.convertTemplateLiteralPartsToPerl(value.parts)}`;
+      }
+      if (value.parsed) {
+        const hashref = objectLiteralExprToPerlHashref(this.spreadCtx, value.parsed);
+        if (hashref !== null)
+          return `${perlHashKey(name)} => ${hashref}`;
+      }
+      return `${perlHashKey(name)} => ${this.convertExpressionToPerl(value.expr)}`;
+    },
+    emitSpread: (value) => {
+      const perlExpr = this.convertExpressionToPerl(value.expr);
+      return perlExpr.startsWith("%") ? perlExpr : `%{${perlExpr}}`;
+    },
+    emitTemplate: (value, name) => `${perlHashKey(name)} => ${this.convertTemplateLiteralPartsToPerl(value.parts)}`,
+    emitBooleanAttr: (_value, name) => `${perlHashKey(name)} => 1`,
+    emitBooleanShorthand: (_value, name) => `${perlHashKey(name)} => 1`,
+    emitJsxChildren: () => ""
+  };
+  renderComponent(comp) {
+    const propParts = [];
+    for (const p of comp.props) {
+      if ((p.name.match(/^on[A-Z]/) || p.name === "ref") && p.value.kind === "expression")
+        continue;
+      const lowered = emitAttrValue(p.value, this.componentPropEmitter, p.name);
+      if (lowered)
+        propParts.push(lowered);
     }
-    if ((op === "!==" || op === "!=") && stringCmp) {
-      return `${l} ne ${r}`;
+    if (comp.slotId && !this.inLoop) {
+      propParts.push(`_bf_slot => '${comp.slotId}'`);
     }
-    const opMap = {
-      "===": "==",
-      "!==": "!=",
-      ">": ">",
-      "<": "<",
-      ">=": ">=",
-      "<=": "<=",
-      "+": "+",
-      "-": "-",
-      "*": "*",
-      "/": "/"
-    };
-    return `${l} ${opMap[op] ?? op} ${r}`;
-  }
-  logical(op, left, right, emit) {
-    const l = emit(left);
-    const r = emit(right);
-    if (op === "&&")
-      return `(${l} && ${r})`;
-    if (op === "||")
-      return `(${l} || ${r})`;
-    return `(${l} // ${r})`;
-  }
-  higherOrder(method, object, param, predicate, emit) {
-    const arrayExpr = emit(object);
-    const predBody = emitParsedExpr(predicate, new MojoFilterEmitter(param, this.localVarMap, this.isStringName));
-    const grepBody = predBody.replace(new RegExp(`\\$${param}\\b`, "g"), "$_");
-    if (method === "filter")
-      return `[grep { ${grepBody} } @{${arrayExpr}}]`;
-    if (method === "every")
-      return `!(grep { !(${grepBody}) } @{${arrayExpr}})`;
-    if (method === "some")
-      return `!!(grep { ${grepBody} } @{${arrayExpr}})`;
-    return arrayExpr;
-  }
-  arrayLiteral(elements, emit) {
-    return `[${elements.map(emit).join(", ")}]`;
+    const propsStr = propParts.length > 0 ? ", " + propParts.join(", ") : "";
+    const tplName = this.toTemplateName(comp.name);
+    const effectiveChildren = comp.children.length > 0 ? comp.children : resolveJsxChildrenProp(comp.props);
+    if (effectiveChildren.length > 0) {
+      const prevInLoop = this.inLoop;
+      this.inLoop = false;
+      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 `<%== bf->render_child('${tplName}'${propsStr}) %>`;
   }
-  arrayMethod(method, object, args, emit) {
-    return renderArrayMethod(method, object, args, emit);
+  childrenCaptureCounter = 0;
+  presenceVarCounter = 0;
+  toTemplateName(componentName) {
+    return componentName.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
   }
-  sortMethod(_method, object, comparator, emit) {
-    return renderSortMethod(emit(object), comparator);
+  renderIfStatement(ifStmt) {
+    const condition = this.convertExpressionToPerl(ifStmt.condition);
+    const consequent = ifStmt.consequent.type === "if-statement" ? this.renderIfStatement(ifStmt.consequent) : this.renderNode(ifStmt.consequent);
+    let result = `% if (${condition}) {
+${consequent}
+`;
+    if (ifStmt.alternate) {
+      if (ifStmt.alternate.type === "if-statement") {
+        const altResult = this.renderIfStatement(ifStmt.alternate);
+        result += altResult.replace(/^% if/, "% } elsif");
+      } else {
+        const alternate = this.renderNode(ifStmt.alternate);
+        result += `% } else {
+${alternate}
+`;
+      }
+    }
+    result += `% }`;
+    return result;
   }
-  reduceMethod(method, object, reduceOp, emit) {
-    return renderReduceMethod(emit(object), reduceOp, method === "reduceRight" ? "right" : "left");
+  renderFragment(fragment) {
+    const children = this.renderChildren(fragment.children);
+    if (fragment.needsScopeComment) {
+      return `<%== bf->scope_comment %>${children}`;
+    }
+    return children;
   }
-  flatMethod(object, depth, emit) {
-    return renderFlatMethod(emit(object), depth);
+  renderSlot(_slot) {
+    return `<%= content %>`;
   }
-  flatMapMethod(object, op, emit) {
-    return renderFlatMapMethod(emit(object), op);
+  renderAsync(node) {
+    const fallback = this.renderNode(node.fallback);
+    const children = this.renderChildren(node.children);
+    const fallbackVar = `$bf_async_fallback_${node.id}`;
+    return `<% my ${fallbackVar} = begin %>${fallback}<% end %><%== bf->async_boundary('${node.id}', ${fallbackVar}) %>
+${children}`;
   }
-  conditional(_test, _consequent, _alternate) {
-    return "1";
+  elementAttrEmitter = {
+    emitLiteral: (value, name) => `${name}="${value.value}"`,
+    emitExpression: (value, name) => {
+      if (name === "style") {
+        const css = this.tryLowerStyleObject(value.expr);
+        if (css !== null)
+          return `style="${css}"`;
+      }
+      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) || this.isBooleanTypedPropRef(value.expr) ? `${name}="<%= bf->bool_str(${perl2}) %>"` : `${name}="<%= ${perl2} %>"`;
+        return `<% if (defined ${perl2}) { %>${body}<% } %>`;
+      }
+      if (isBooleanAttr(name)) {
+        return `<%= ${this.convertExpressionToPerl(value.expr)} ? '${name}' : '' %>`;
+      }
+      if (value.presenceOrUndefined) {
+        const perl2 = this.convertExpressionToPerl(value.expr);
+        const tmp = `$bf_pu${this.presenceVarCounter++}`;
+        const body = isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name) || this.isBooleanTypedPropRef(value.expr) ? `${name}="<%= bf->bool_str(${tmp}) %>"` : `${name}="<%= ${tmp} %>"`;
+        return `<% my ${tmp} = ${perl2}; if (${tmp}) { %>${body}<% } %>`;
+      }
+      {
+        const m = this.parseUndefinedAlternateTernary(value.expr);
+        if (m) {
+          const cond = this.convertExpressionToPerl(m.condition);
+          const val = this.convertExpressionToPerl(m.consequent);
+          return `<% if (${cond}) { %>${name}="<%= ${val} %>"<% } %>`;
+        }
+      }
+      const perl = this.convertExpressionToPerl(value.expr);
+      if (isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name) || this.isBooleanTypedPropRef(value.expr)) {
+        return `${name}="<%= bf->bool_str(${perl}) %>"`;
+      }
+      return `${name}="<%= ${perl} %>"`;
+    },
+    emitBooleanAttr: (_value, name) => name,
+    emitTemplate: (value, name) => `${name}="<%= ${this.convertTemplateLiteralPartsToPerl(value.parts)} %>"`,
+    emitSpread: (value) => {
+      if (this.refuseUnsupportedAttrExpression(value.expr, "...")) {
+        return "";
+      }
+      const trimmed = value.expr.trim();
+      if (this.propsObjectName && this.propsObjectName === trimmed) {
+        const entries = this.propsParams.map((p) => `${JSON.stringify(p.name)} => $${p.name}`);
+        return `<%== bf->spread_attrs({${entries.join(", ")}}) %>`;
+      }
+      const ternaryHashref = conditionalSpreadToPerl(this.spreadCtx, value.parsed);
+      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 = conditionalSpreadToPerl(this.spreadCtx, parseExpression2(initTrimmed));
+            if (resolved !== null) {
+              return `<%== bf->spread_attrs(${resolved}) %>`;
+            }
+          }
+        }
+      }
+      const perlExpr = this.convertExpressionToPerl(value.expr);
+      return `<%== bf->spread_attrs(${perlExpr}) %>`;
+    },
+    emitBooleanShorthand: () => "",
+    emitJsxChildren: () => ""
+  };
+  tryLowerStyleObject(expr) {
+    const entries = parseStyleObjectEntries(expr);
+    if (!entries)
+      return null;
+    for (const e of entries) {
+      if (e.kind === "expr" && !isSupported(parseExpression2(e.expr)).supported)
+        return null;
+    }
+    return entries.map((e) => e.kind === "literal" ? `${this.escapeAttrText(e.cssKey)}:${this.escapeAttrText(e.value)}` : `${this.escapeAttrText(e.cssKey)}:<%= ${this.convertExpressionToPerl(e.expr)} %>`).join(";");
   }
-  templateLiteral(_parts) {
-    return "1";
+  escapeAttrText(s) {
+    return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
   }
-  arrowFn(_param, _body) {
-    return "1";
+  renderAttributes(element) {
+    const parts = [];
+    for (const attr of element.attrs) {
+      if (attr.clientOnly)
+        continue;
+      let attrName;
+      if (attr.name === "className")
+        attrName = "class";
+      else if (attr.name === "key")
+        attrName = "data-key";
+      else
+        attrName = attr.name;
+      const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, attrName);
+      if (lowered)
+        parts.push(lowered);
+    }
+    return parts.length > 0 ? " " + parts.join(" ") : "";
   }
-  unsupported(_raw, _reason) {
-    return "1";
+  renderScopeMarker(_instanceIdExpr) {
+    return `bf-s="<%= bf->scope_attr %>" <%== bf->hydration_attrs %> <%== bf->props_attr %>`;
   }
-}
-
-class MojoTopLevelEmitter {
-  adapter;
-  constructor(adapter) {
-    this.adapter = adapter;
+  renderSlotMarker(slotId) {
+    return `${BF_SLOT}="${slotId}"`;
   }
-  identifier(name) {
-    if (name === "undefined" || name === "null")
-      return "undef";
-    const inlined = this.adapter.resolveModuleStringConst(name);
-    if (inlined !== null)
-      return inlined;
-    const literalConst = this.adapter.resolveLiteralConst(name);
-    if (literalConst !== null)
-      return literalConst;
-    return `$${name}`;
+  renderCondMarker(condId) {
+    return `${BF_COND}="${condId}"`;
   }
-  literal(value, literalType) {
-    if (literalType === "string")
-      return `'${value}'`;
-    if (literalType === "boolean")
-      return value ? "1" : "0";
-    if (literalType === "null")
-      return "undef";
-    return String(value);
+  renderPerlFilterExpr(expr, param, localVarMap = new Map) {
+    return emitParsedExpr2(expr, new MojoFilterEmitter(param, localVarMap, (n) => this._isStringValueName(n), (message, reason) => this._recordExprBF101(message, reason)));
   }
-  member(object, property, _computed, emit) {
-    if (object.kind === "identifier" && object.name === "props") {
-      return `$${property}`;
-    }
-    if (object.kind === "identifier") {
-      const staticValue = this.adapter.resolveStaticRecordLiteral(object.name, property);
-      if (staticValue !== null)
-        return staticValue;
+  convertTemplateLiteralPartsToPerl(literalParts) {
+    const parts = [];
+    for (const part of literalParts) {
+      if (part.type === "string") {
+        parts.push(this.substituteJsInterpolationsToPerl(part.value));
+      } else if (part.type === "ternary") {
+        const cond = this.convertExpressionToPerl(part.condition);
+        parts.push(`(${cond} ? '${part.whenTrue}' : '${part.whenFalse}')`);
+      } else if (part.type === "lookup") {
+        const keyExpr = this.convertExpressionToPerl(part.key);
+        const entries = Object.entries(part.cases).map(([k, v]) => `'${k}' => '${v}'`).join(", ");
+        parts.push(`({ ${entries} }->{${keyExpr}} // '')`);
+      }
     }
-    const obj = emit(object);
-    if (property === "length")
-      return `scalar(@{${obj}})`;
-    return `${obj}->{${property}}`;
-  }
-  indexAccess(object, index, emit) {
-    return emitIndexAccessPerl(object, index, emit, (n) => this.adapter._isStringValueName(n));
+    return parts.length === 1 ? parts[0] : parts.join(" . ");
   }
-  call(callee, args, emit) {
-    if (callee.kind === "identifier" && args.length === 0) {
-      return `$${callee.name}`;
-    }
-    if (this.adapter._searchParamsLocals.size > 0) {
-      const sp = matchSearchParamsMethodCall(callee, args, this.adapter._searchParamsLocals);
-      if (sp) {
-        return `$searchParams->${sp.method}(${sp.args.map(emit).join(", ")})`;
+  substituteJsInterpolationsToPerl(s) {
+    const segments = [];
+    const re = /\$\{([^}]+)\}/g;
+    let lastIndex = 0;
+    let m;
+    while ((m = re.exec(s)) !== null) {
+      if (m.index > lastIndex) {
+        segments.push(`'${s.slice(lastIndex, m.index)}'`);
       }
+      segments.push(this.convertExpressionToPerl(m[1].trim()));
+      lastIndex = re.lastIndex;
     }
-    const path = identifierPath(callee);
-    const spec = path ? MOJO_TEMPLATE_PRIMITIVES[path] : undefined;
-    if (path && spec) {
-      if (args.length === spec.arity) {
-        return spec.emit(args.map(emit));
-      }
-      this.adapter._recordExprBF101(`templatePrimitive '${path}' expects ${spec.arity} arg(s), got ${args.length}`, `Call '${path}' with exactly ${spec.arity} argument(s).`);
-      return "''";
+    if (lastIndex < s.length) {
+      segments.push(`'${s.slice(lastIndex)}'`);
     }
-    return emit(callee);
+    if (segments.length === 0)
+      return `''`;
+    return segments.length === 1 ? segments[0] : `(${segments.join(" . ")})`;
   }
-  unary(op, argument, emit) {
-    const arg = emit(argument);
-    if (op === "!")
-      return `!${arg}`;
-    if (op === "-")
-      return `-${arg}`;
-    return arg;
+  refuseUnsupportedAttrExpression(expr, attrName) {
+    let probe = expr.trim();
+    while (probe.startsWith("("))
+      probe = probe.slice(1).trimStart();
+    const startsAsObjectLiteral = probe.startsWith("{");
+    const hasTaggedTemplate = /[A-Za-z_$][\w$]*\s*`/.test(probe);
+    if (!startsAsObjectLiteral && !hasTaggedTemplate)
+      return false;
+    const parsed = parseExpression2(expr.trim());
+    const support = isSupported(parsed);
+    if (parsed.kind !== "unsupported" && support.supported)
+      return false;
+    const reason = support.reason ?? (parsed.kind === "unsupported" ? parsed.reason : undefined);
+    const reasonLine = reason ? `
+${reason}` : "";
+    this.errors.push({
+      code: "BF101",
+      severity: "error",
+      message: `Expression not supported on attribute '${attrName}': ${expr.trim()}${reasonLine}`,
+      loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+      suggestion: {
+        message: "The Mojo adapter cannot lower JS object literals or tagged-template-literal expressions into Embedded Perl. Move the expression into a `'use client'` component (so hydration computes it), or expand it into discrete attributes whose values are values the adapter can lower."
+      }
+    });
+    return true;
   }
-  binary(op, left, right, emit) {
-    const l = emit(left);
-    const r = emit(right);
-    const isStr = (e) => isStringTypedOperand(e, (n) => this.adapter._isStringValueName(n));
-    const stringCmp = isStr(left) || isStr(right);
-    if ((op === "===" || op === "==") && stringCmp) {
-      return `${l} eq ${r}`;
-    }
-    if ((op === "!==" || op === "!=") && stringCmp) {
-      return `${l} ne ${r}`;
-    }
-    const opMap = {
-      "===": "==",
-      "!==": "!=",
-      ">": ">",
-      "<": "<",
-      ">=": ">=",
-      "<=": "<=",
-      "+": "+",
-      "-": "-",
-      "*": "*"
+  get emitCtx() {
+    return {
+      _searchParamsLocals: this._searchParamsLocals,
+      resolveModuleStringConst: (name) => this.resolveModuleStringConst(name),
+      resolveLiteralConst: (name) => this.resolveLiteralConst(name),
+      resolveStaticRecordLiteral: (o, k) => this.resolveStaticRecordLiteral(o, k),
+      _isStringValueName: (name) => this._isStringValueName(name),
+      _recordExprBF101: (message, reason) => this._recordExprBF101(message, reason),
+      _renderPerlFilterExprPublic: (e, p) => this._renderPerlFilterExprPublic(e, p)
     };
-    return `${l} ${opMap[op] ?? op} ${r}`;
-  }
-  logical(op, left, right, emit) {
-    const l = emit(left);
-    const r = emit(right);
-    if (op === "&&")
-      return `(${l} && ${r})`;
-    if (op === "||")
-      return `(${l} || ${r})`;
-    return `(${l} // ${r})`;
   }
-  higherOrder(method, object, param, predicate, emit) {
-    const arrayExpr = emit(object);
-    const predBody = this.adapter._renderPerlFilterExprPublic(predicate, param);
-    const grepBody = predBody.replace(new RegExp(`\\$${param}\\b`, "g"), "$_");
-    if (method === "filter")
-      return `[grep { ${grepBody} } @{${arrayExpr}}]`;
-    if (method === "every")
-      return `!(grep { !(${grepBody}) } @{${arrayExpr}})`;
-    if (method === "some")
-      return `!!(grep { ${grepBody} } @{${arrayExpr}})`;
-    const findHelper = {
-      find: "find",
-      findIndex: "find_index",
-      findLast: "find_last",
-      findLastIndex: "find_last_index"
+  get spreadCtx() {
+    return {
+      componentName: this.componentName,
+      errors: this.errors,
+      localConstants: this.localConstants,
+      propsParams: this.propsParams,
+      convertExpressionToPerl: (e, preParsed) => this.convertExpressionToPerl(e, preParsed)
     };
-    if (findHelper[method]) {
-      return `bf->${findHelper[method]}(${arrayExpr}, sub { my $${param} = $_[0]; ${predBody} })`;
-    }
-    return arrayExpr;
-  }
-  arrayLiteral(elements, emit) {
-    return `[${elements.map(emit).join(", ")}]`;
-  }
-  arrayMethod(method, object, args, emit) {
-    return renderArrayMethod(method, object, args, emit);
-  }
-  sortMethod(_method, object, comparator, emit) {
-    return renderSortMethod(emit(object), comparator);
-  }
-  reduceMethod(method, object, reduceOp, emit) {
-    return renderReduceMethod(emit(object), reduceOp, method === "reduceRight" ? "right" : "left");
-  }
-  flatMethod(object, depth, emit) {
-    return renderFlatMethod(emit(object), depth);
   }
-  flatMapMethod(object, op, emit) {
-    return renderFlatMapMethod(emit(object), op);
-  }
-  conditional(test, consequent, alternate, emit) {
-    return `(${emit(test)} ? ${emit(consequent)} : ${emit(alternate)})`;
+  get memoCtx() {
+    return { convertExpressionToPerl: (e, preParsed) => this.convertExpressionToPerl(e, preParsed) };
   }
-  templateLiteral(parts, emit) {
-    const terms = [];
-    for (const part of parts) {
-      if (part.type === "string") {
-        if (part.value !== "") {
-          terms.push(`"${part.value.replace(/[\\"$@]/g, (m) => `\\${m}`)}"`);
+  convertExpressionToPerl(expr, preParsed) {
+    let parsed;
+    if (preParsed) {
+      parsed = preParsed;
+    } else {
+      const trimmed = expr.trim();
+      if (trimmed === "")
+        return "''";
+      parsed = parseExpression2(trimmed);
+    }
+    if (parsed.kind === "call") {
+      for (const matcher of this._loweringMatchers) {
+        const node = matcher(parsed.callee, parsed.args);
+        if (node?.kind === "guard-list" && node.helper === "query") {
+          const argsGo = queryHrefArgs(node, (n) => this.renderParsedExprToPerl(n));
+          return `bf->query(${argsGo.join(", ")})`;
         }
-      } else {
-        const rendered = emit(part.expr);
-        const needsParens = part.expr.kind === "binary" || part.expr.kind === "logical" || part.expr.kind === "conditional";
-        terms.push(needsParens ? `(${rendered})` : rendered);
       }
     }
-    if (terms.length === 0)
-      return '""';
-    return terms.join(" . ");
+    const support = isSupported(parsed);
+    if (!support.supported) {
+      this.errors.push({
+        code: "BF101",
+        severity: "error",
+        message: `Expression not supported: ${preParsed ? stringifyParsedExpr2(parsed) : expr.trim()}`,
+        loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+        suggestion: {
+          message: support.reason ? `${support.reason}
+
+Options:
+1. Use /* @client */ for client-side evaluation
+2. Pre-compute the value in Perl` : `Options:
+1. Use /* @client */ for client-side evaluation
+2. Pre-compute the value in Perl`
+        }
+      });
+      return "''";
+    }
+    return this.renderParsedExprToPerl(parsed);
   }
-  arrowFn(_param, _body) {
-    return "''";
+  renderParsedExprToPerl(expr) {
+    return emitParsedExpr2(expr, new MojoTopLevelEmitter(this.emitCtx));
   }
-  unsupported(_raw, _reason) {
-    return "''";
+  _isStringValueName(name) {
+    return this.stringValueNames.has(name);
+  }
+  _recordExprBF101(message, reason) {
+    this.errors.push({
+      code: "BF101",
+      severity: "error",
+      message,
+      loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+      suggestion: {
+        message: reason ? `${reason}
+
+Options:
+1. Use /* @client */ for client-side evaluation
+2. Pre-compute the value in Perl` : `Options:
+1. Use /* @client */ for client-side evaluation
+2. Pre-compute the value in Perl`
+      }
+    });
+  }
+  _renderPerlFilterExprPublic(expr, param) {
+    return this.renderPerlFilterExpr(expr, param);
   }
 }
 var mojoAdapter = new MojoAdapter;