@barefootjs/mojolicious 0.30.6 → 0.31.0

package/dist/build.js

@@ -1,1933 +0,0 @@
-// src/adapter/mojo-adapter.ts
-import {
-  BaseAdapter,
-  isBooleanAttr,
-  parseExpression as parseExpression2,
-  stringifyParsedExpr as stringifyParsedExpr2,
-  parseStyleObjectEntries,
-  isSupported,
-  exprToString,
-  parseProviderObjectLiteral,
-  emitParsedExpr as emitParsedExpr2,
-  emitIRNode,
-  emitAttrValue,
-  augmentInheritedPropAccesses,
-  collectModuleStringConsts,
-  lookupStaticRecordLiteral,
-  searchParamsLocalNames,
-  prepareLoweringMatchers,
-  queryHrefArgs,
-  isValidHelperId,
-  sortComparatorFromArrow as sortComparatorFromArrow2,
-  isLowerableLoopDestructure,
-  isDangerousInnerHtmlAttr,
-  resolveDangerousInnerHtml,
-  dangerousInnerHtmlMetacharViolation,
-  dangerousInnerHtmlDiagnostic,
-  resolveStaticLoopSource,
-  derivesScopeFromSlot
-} from "@barefootjs/jsx";
-
-// src/adapter/boolean-result.ts
-import { parseExpression } from "@barefootjs/jsx";
-var COMPARISON_OPS = new Set([
-  "<",
-  ">",
-  "<=",
-  ">=",
-  "==",
-  "===",
-  "!=",
-  "!=="
-]);
-function isBooleanResultParsed(node) {
-  switch (node.kind) {
-    case "literal":
-      return node.literalType === "boolean";
-    case "binary":
-      return COMPARISON_OPS.has(node.op);
-    case "unary":
-      return node.op === "!";
-    case "logical":
-      return isBooleanResultParsed(node.left) && isBooleanResultParsed(node.right);
-    case "conditional":
-      return isBooleanResultParsed(node.consequent) && isBooleanResultParsed(node.alternate);
-    default:
-      return false;
-  }
-}
-function isBooleanResultExpr(expr) {
-  const parsed = parseExpression(expr.trim());
-  if (!parsed)
-    return false;
-  return isBooleanResultParsed(parsed);
-}
-var ARIA_BOOLEAN_ATTRS = new Set([
-  "aria-atomic",
-  "aria-busy",
-  "aria-disabled",
-  "aria-hidden",
-  "aria-modal",
-  "aria-multiline",
-  "aria-multiselectable",
-  "aria-readonly",
-  "aria-required",
-  "aria-selected",
-  "aria-expanded",
-  "aria-checked",
-  "aria-pressed"
-]);
-function isAriaBooleanAttr(name) {
-  return ARIA_BOOLEAN_ATTRS.has(name);
-}
-
-// src/adapter/mojo-adapter.ts
-import { BF_SLOT, BF_COND, BF_REGION, escapeHtml } 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]})` },
-  Number: { arity: 1, emit: (args) => `bf->number(${args[0]})` },
-  "Math.floor": { arity: 1, emit: (args) => `bf->floor(${args[0]})` },
-  "Math.ceil": { arity: 1, emit: (args) => `bf->ceil(${args[0]})` },
-  "Math.round": { arity: 1, emit: (args) => `bf->round(${args[0]})` },
-  "Math.min": { arity: 2, emit: (args) => `bf->min(${args[0]}, ${args[1]})` },
-  "Math.max": { arity: 2, emit: (args) => `bf->max(${args[0]}, ${args[1]})` },
-  "Math.abs": { arity: 1, emit: (args) => `bf->abs(${args[0]})` },
-  isValidElement: { arity: 1, emit: (args) => `bf->is_element(${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)
-    return [];
-  if (prop.value.kind !== "jsx-children")
-    return [];
-  return prop.value.children;
-}
-function collectRootScopeNodes(node) {
-  const out = new Set;
-  const visit = (n) => {
-    if (!n)
-      return;
-    if (n.type === "element") {
-      out.add(n);
-      return;
-    }
-    if (n.type === "if-statement") {
-      const s = n;
-      visit(s.consequent);
-      visit(s.alternate);
-      return;
-    }
-    if (n.type === "fragment") {
-      for (const c of n.children)
-        visit(c);
-    }
-  };
-  visit(node);
-  return out;
-}
-
-// 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 `bf->join(${obj}, ${sep})`;
-    }
-    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})`;
-    }
-    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})`;
-    }
-    case "reverse":
-    case "toReversed": {
-      const recv = emit(object);
-      return `bf->reverse(${recv})`;
-    }
-    case "toLowerCase": {
-      const recv = emit(object);
-      return `lc(${recv})`;
-    }
-    case "toUpperCase": {
-      const recv = emit(object);
-      return `uc(${recv})`;
-    }
-    case "trim": {
-      const recv = emit(object);
-      return `bf->trim(${recv})`;
-    }
-    case "trimStart":
-    case "trimEnd": {
-      const fn = method === "trimStart" ? "trim_start" : "trim_end";
-      const recv = emit(object);
-      return `bf->${fn}(${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 "replaceAll": {
-      const recv = emit(object);
-      const oldS = emit(args[0]);
-      const newS = emit(args[1]);
-      return `bf->replace_all(${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}'`);
-    }
-  }
-}
-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;
-  }
-  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, emit) {
-  if (typeof depth === "object") {
-    return `bf->flat_dynamic(${recv}, ${emit(depth.expr)})`;
-  }
-  const d = depth === "infinity" ? -1 : depth;
-  return `bf->flat(${recv}, ${d})`;
-}
-
-// src/adapter/lib/static-value.ts
-function escapePerlSingleQuote2(s) {
-  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-}
-function staticValueToPerl(value) {
-  if (value === null || value === undefined)
-    return "undef";
-  if (typeof value === "boolean")
-    return null;
-  if (typeof value === "number")
-    return String(value);
-  if (typeof value === "string")
-    return `'${escapePerlSingleQuote2(value)}'`;
-  if (Array.isArray(value)) {
-    const items = [];
-    for (const el of value) {
-      const serialized = staticValueToPerl(el);
-      if (serialized === null)
-        return null;
-      items.push(serialized);
-    }
-    return `[${items.join(", ")}]`;
-  }
-  if (typeof value === "object") {
-    const entries = [];
-    for (const [key, val] of Object.entries(value)) {
-      const serialized = staticValueToPerl(val);
-      if (serialized === null)
-        return null;
-      entries.push(`${perlHashKey(key)} => ${serialized}`);
-    }
-    return `{ ${entries.join(", ")} }`;
-  }
-  return null;
-}
-
-// src/adapter/expr/emitters.ts
-import {
-  groupBinaryOperand,
-  isStringTypedOperand,
-  isStringConcatBinary,
-  emitParsedExpr,
-  identifierPath,
-  matchSearchParamsMethodCall,
-  sortComparatorFromArrow,
-  asCallbackMethodCall
-} from "@barefootjs/jsx";
-
-// src/adapter/expr/operand.ts
-function emitIndexAccessPerl(object, index, emit, isStringName) {
-  return `bf->get(${emit(object)}, ${emit(index)})`;
-}
-
-// 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;
-  }
-  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, _optional, emit) {
-    if (property === "length" && (asCallbackMethodCall(object) !== null || object.kind === "array-literal")) {
-      return `scalar(@{${emit(object)}})`;
-    }
-    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}`;
-    }
-    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}`;
-    }
-    if (op === "-")
-      return `-${arg}`;
-    return arg;
-  }
-  binary(op, left, right, emit) {
-    const l = groupBinaryOperand(left, emit(left));
-    const r = groupBinaryOperand(right, 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}`;
-    }
-    if (isStringConcatBinary(op, left, right, this.isStringName)) {
-      return `${l} . ${r}`;
-    }
-    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})`;
-  }
-  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;
-  }
-  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, emit);
-  }
-  conditional(_test, _consequent, _alternate) {
-    return "1";
-  }
-  templateLiteral(_parts) {
-    return "1";
-  }
-  arrow(_params, _body, _emit) {
-    return "1";
-  }
-  regex(_raw) {
-    return "1";
-  }
-  unsupported(_raw, _reason) {
-    return "1";
-  }
-  objectLiteral(_properties, _raw, _emit) {
-    return "1";
-  }
-}
-
-class MojoTopLevelEmitter {
-  ctx;
-  constructor(ctx) {
-    this.ctx = ctx;
-  }
-  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, _optional, emit) {
-    if (object.kind === "identifier" && object.name === "props") {
-      return `$${property}`;
-    }
-    if (object.kind === "identifier") {
-      const staticValue = this.ctx.resolveStaticRecordLiteral(object.name, property);
-      if (staticValue !== null)
-        return staticValue;
-    }
-    const obj = emit(object);
-    if (property === "length") {
-      const isStr = (e) => isStringTypedOperand(e, (n) => this.ctx._isStringValueName(n));
-      const isStringReceiver = isStr(object) || object.kind === "identifier" && this.ctx._isStringValueName(object.name);
-      if (isStringReceiver)
-        return `bf->length(${obj})`;
-      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 (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 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 emit(callee);
-  }
-  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 = groupBinaryOperand(left, emit(left));
-    const r = groupBinaryOperand(right, 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}`;
-    }
-    if ((op === "!==" || op === "!=") && stringCmp) {
-      return `${l} ne ${r}`;
-    }
-    if (isStringConcatBinary(op, left, right, (n) => this.ctx._isStringValueName(n))) {
-      return `${l} . ${r}`;
-    }
-    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})`;
-  }
-  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 "''";
-    }
-    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 "''";
-    }
-    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 "''";
-    }
-    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 "''";
-    }
-    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 arrayExpr;
-  }
-  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, emit);
-  }
-  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 (terms.length === 0)
-      return '""';
-    return terms.join(" . ");
-  }
-  arrow(_params, _body, _emit) {
-    return "''";
-  }
-  regex(_raw) {
-    return "''";
-  }
-  unsupported(_raw, _reason) {
-    return "''";
-  }
-  objectLiteral(properties, _raw, _emit) {
-    return properties.length === 0 ? "{}" : "''";
-  }
-}
-
-// 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;
-      }
-    }
-  };
-  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;
-  }
-  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: `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: "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 : ctx.convertExpressionToPerl("", val);
-    entries.push(`'${key.replace(/'/g, "\\'")}' => ${valPerl}`);
-  }
-  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/props/prop-classes.ts
-import { collectLoopBoundNames } from "@barefootjs/jsx";
-
-// 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" || p.optional)).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);
-    }
-  }
-  for (const p of ir.metadata.propsParams) {
-    if (isStringTypeInfo(p.type))
-      names.add(p.name);
-  }
-  for (const c of ir.metadata.localConstants) {
-    if (isStringTypeInfo(c.type ?? undefined) || isBareStringLiteral(c.value))
-      names.add(c.name);
-  }
-  for (const bound of collectLoopBoundNames(ir))
-    names.delete(bound);
-  return names;
-}
-
-// src/adapter/mojo-adapter.ts
-function perlSegmentAccessor(base, segments) {
-  let expr = base;
-  for (const seg of segments) {
-    expr += seg.kind === "field" ? `->{${seg.isIdent ? seg.key : perlHashKey(seg.key)}}` : `->[${seg.index}]`;
-  }
-  return expr;
-}
-function perlStringLiteral(s) {
-  return `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
-}
-
-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 = [];
-  currentLoopKeyDepth = 0;
-  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);
-    }
-    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);
-    }
-    if (!/^[A-Za-z_$][\w$]*$/.test(bare))
-      return false;
-    if (this.loopBoundNames.has(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)
-    };
-  }
-  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;
-  }
-  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}`)}'`;
-  }
-  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}`)}'`;
-  }
-  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(`
-`);
-  }
-  renderNode(node) {
-    return emitIRNode(node, this, {});
-  }
-  emitElement(node, _ctx, _emit) {
-    return this.renderElement(node);
-  }
-  emitText(node) {
-    return escapeHtml(node.value);
-  }
-  emitExpression(node) {
-    return this.renderExpression(node);
-  }
-  emitConditional(node, _ctx, _emit) {
-    return this.renderConditional(node);
-  }
-  emitLoop(node, _ctx, _emit) {
-    return this.renderLoop(node);
-  }
-  emitComponent(node, _ctx, _emit) {
-    return this.renderComponent(node);
-  }
-  emitFragment(node, _ctx, _emit) {
-    return this.renderFragment(node);
-  }
-  emitSlot(node) {
-    return this.renderSlot(node);
-  }
-  emitIfStatement(node, _ctx, _emit) {
-    return this.renderIfStatement(node);
-  }
-  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}'); %>`;
-  }
-  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";
-  }
-  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;
-      if (this.isClientOnlyContextIdentifier(src))
-        return `${key} => undef`;
-      return `${key} => ${this.convertExpressionToPerl(src)}`;
-    });
-    return `{ ${entries.join(", ")} }`;
-  }
-  isClientOnlyContextIdentifier(src) {
-    const t = src.trim();
-    if (!/^[A-Za-z_$][\w$]*$/.test(t))
-      return false;
-    return !this.providerDataNames.has(t) && !this.moduleStringConsts.has(t);
-  }
-  emitAsync(node, _ctx, _emit) {
-    return this.renderAsync(node);
-  }
-  renderElement(element) {
-    const tag = element.tag;
-    const attrs = this.renderAttributes(element);
-    const dangerousHtml = this.renderDangerousInnerHtml(element);
-    const children = dangerousHtml !== null ? dangerousHtml : this.renderChildren(element.children);
-    let hydrationAttrs = "";
-    if (element.needsScope) {
-      hydrationAttrs += ` ${this.renderScopeMarker("")}`;
-    }
-    if (this.rootScopeNodes.has(element) && element.needsScope) {
-      hydrationAttrs += ` <%== bf->data_key_attr %>`;
-    }
-    if (element.slotId) {
-      hydrationAttrs += ` ${this.renderSlotMarker(element.slotId)}`;
-    }
-    if (element.regionId) {
-      hydrationAttrs += ` ${BF_REGION}="${element.regionId}"`;
-    }
-    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}>`;
-  }
-  renderDangerousInnerHtml(element) {
-    const resolution = resolveDangerousInnerHtml(element);
-    if (!resolution)
-      return null;
-    if (resolution.kind === "unlowerable") {
-      this.errors.push(dangerousInnerHtmlDiagnostic(resolution.expr, resolution.loc));
-      return "";
-    }
-    if (resolution.kind === "dynamic") {
-      return `<%== ${this.convertExpressionToPerl(resolution.valueExpr, resolution.valueParsed)} %>`;
-    }
-    const violation = dangerousInnerHtmlMetacharViolation(resolution.html, this.name);
-    if (violation) {
-      const attr = element.attrs.find(isDangerousInnerHtmlAttr);
-      this.errors.push(dangerousInnerHtmlDiagnostic(`{ __html: ${JSON.stringify(resolution.html)} }`, attr.loc, violation));
-      return "";
-    }
-    return resolution.html;
-  }
-  renderExpression(expr) {
-    if (expr.clientOnly) {
-      if (expr.markerless)
-        return "";
-      if (expr.slotId) {
-        return `<%== bf->text_start("${expr.slotId}") %><%== bf->text_end %>`;
-      }
-      return "";
-    }
-    const perlExpr = this.convertExpressionToPerl(expr.expr, expr.parsed);
-    if (expr.slotId) {
-      return `<%== bf->text_start("${expr.slotId}") %><%= ${perlExpr} %><%== bf->text_end %>`;
-    }
-    return `<%= ${perlExpr} %>`;
-  }
-  renderConditional(cond) {
-    if (cond.clientOnly && cond.slotId) {
-      return `<%== bf->comment("cond-start:${cond.slotId}") %><%== bf->comment("cond-end:${cond.slotId}") %>`;
-    }
-    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;
-    }
-    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}
-% }
-`;
-    }
-    return result;
-  }
-  renderNodeOrNull(node) {
-    if (node.type === "expression" && (node.expr === "null" || node.expr === "undefined")) {
-      return null;
-    }
-    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`);
-    }
-    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}") %>`;
-    }
-    const destructure = !!(loop.paramBindings && loop.paramBindings.length > 0);
-    const supportableDestructure = destructure && isLowerableLoopDestructure(loop);
-    if (destructure && !supportableDestructure) {
-      this.errors.push({
-        code: "BF104",
-        severity: "error",
-        message: `Loop callback uses a destructure pattern (\`${loop.param}\`) that the Mojo adapter cannot lower — see the diagnostic detail for the specific shape.`,
-        loc: loop.loc ?? { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
-        suggestion: {
-          message: `Options:
-` + `  1. If this is an object-rest binding (\`{ ...rest }\`), only reading \`rest.field\` or spreading \`{...rest}\` onto an intrinsic element lowers — other uses (passing \`rest\` to a function, rendering it as text) need the client runtime.
-` + `  2. If this is chained \`.filter().map(({ ... }) => ...)\`, hoist the destructure into a variable inside the callback body instead.
-` + `  3. Mark the loop position as @client-only so the destructure runs in JS on the client.
-` + `  4. Move the loop into a primitive that the adapter registers explicitly.`
-        }
-      });
-    }
-    const staticItems = resolveStaticLoopSource(loop.arrayParsed, this.localConstants, {
-      isNameShadowed: (name) => this.loopBoundNames.has(name)
-    });
-    const staticArray = staticItems !== null ? staticValueToPerl(staticItems) : null;
-    const arrayName = loop.array.trim();
-    if (staticArray === null && /^[A-Za-z_$][\w$]*$/.test(arrayName)) {
-      const arrayConst = (this.localConstants ?? []).find((c) => c.name === arrayName);
-      if (arrayConst && !arrayConst.isModule && this.resolveLiteralConst(arrayName) === null) {
-        this.errors.push({
-          code: "BF101",
-          severity: "error",
-          message: `Loop array \`${arrayName}\` is a local computed value (\`${arrayConst.value}\`) that the Mojo adapter cannot bind as a template variable — only numeric/string-literal locals inline at their use site.`,
-          loc: loop.loc ?? { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
-          suggestion: {
-            message: "Pre-compute the array server-side and pass it as a prop, or mark the loop position as @client-only so it runs in JS on the client."
-          }
-        });
-      }
-    }
-    const rawArray = staticArray ?? 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.objectIteration === "entries" ? [param, loop.index ?? "_k"] : loop.objectIteration === "keys" || loop.objectIteration === "values" || loop.iterationShape === "keys" ? [param] : supportableDestructure ? ["__bf_item", ...(loop.paramBindings ?? []).map((b) => b.name), loop.index ?? "_i"] : [param, loop.index ?? "_i"];
-    const preambleDecls = loop.preamble?.declarations ?? [];
-    for (const d of preambleDecls)
-      loopBound.push(d.name);
-    for (const n of loopBound) {
-      this.loopBoundNames.set(n, (this.loopBoundNames.get(n) ?? 0) + 1);
-    }
-    const prevLoopKeyDepth = this.currentLoopKeyDepth;
-    this.currentLoopKeyDepth = loop.depth;
-    const renderedChildren = this.renderChildren(loop.children);
-    this.currentLoopKeyDepth = prevLoopKeyDepth;
-    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 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);
-      }
-      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};`);
-    }
-    if (loop.objectIteration) {
-      const keyVar = loop.objectIteration === "values" ? "$__bf_k" : `$${loop.index ?? param}`;
-      lines.push(`% for my ${keyVar} (sort keys %{${array}}) {`);
-      if (loop.objectIteration === "entries" || loop.objectIteration === "values") {
-        lines.push(`% my $${param} = ${array}->{${keyVar}};`);
-      }
-    } else {
-      lines.push(`% for my ${indexVar} (0..$#{${array}}) {`);
-      if (loop.iterationShape !== "keys") {
-        if (supportableDestructure) {
-          lines.push(`% my $__bf_item = ${array}->[${indexVar}];`);
-          for (const b of loop.paramBindings ?? []) {
-            const parent = perlSegmentAccessor("$__bf_item", b.segments ?? []);
-            if (b.rest?.kind === "object") {
-              const exclude = b.rest.exclude.map((k) => perlStringLiteral(k.key)).join(", ");
-              lines.push(`% my $${b.name} = bf->omit(${parent}, [${exclude}]);`);
-            } else if (b.rest?.kind === "array") {
-              lines.push(`% my $${b.name} = bf->slice(${parent}, ${b.rest.from}, undef);`);
-            } else {
-              lines.push(`% my $${b.name} = ${perlSegmentAccessor("$__bf_item", b.segments ?? [])};`);
-            }
-          }
-        } else {
-          lines.push(`% my $${param} = ${array}->[${indexVar}];`);
-        }
-      }
-    }
-    const preambleLines = preambleDecls.map((d) => `% my $${d.name} = ${this.convertExpressionToPerl(d.raw, d.valueParsed)};`);
-    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(...preambleLines);
-      lines.push(children);
-      lines.push(`% }`);
-    } else {
-      lines.push(...preambleLines);
-      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(`
-`);
-  }
-  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 = [];
-    const namedSlotCaptures = [];
-    for (const p of comp.props) {
-      if ((p.name.match(/^on[A-Z]/) || p.name === "ref") && p.value.kind === "expression")
-        continue;
-      if (p.value.kind === "jsx-children" && p.name !== "children") {
-        const slotBody = this.renderChildren(p.value.children);
-        const varName = `$bf_prop_${this.childrenCaptureCounter++}`;
-        namedSlotCaptures.push(`<% my ${varName} = begin %>${slotBody}<% end %>`);
-        propParts.push(`${perlHashKey(p.name)} => ${varName}`);
-        continue;
-      }
-      const lowered = emitAttrValue(p.value, this.componentPropEmitter, p.name);
-      if (lowered)
-        propParts.push(lowered);
-    }
-    if (derivesScopeFromSlot(comp)) {
-      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 childrenBody = this.renderChildren(effectiveChildren);
-      const varName = `$bf_children_${comp.slotId ?? "c" + this.childrenCaptureCounter++}`;
-      return `${namedSlotCaptures.join("")}<% my ${varName} = begin %>${childrenBody}<% end %><%== bf->render_child('${tplName}'${propsStr}, children => ${varName}) %>`;
-    }
-    return `${namedSlotCaptures.join("")}<%== bf->render_child('${tplName}'${propsStr}) %>`;
-  }
-  childrenCaptureCounter = 0;
-  presenceVarCounter = 0;
-  toTemplateName(componentName) {
-    return componentName.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
-  }
-  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;
-  }
-  renderFragment(fragment) {
-    const children = this.renderChildren(fragment.children);
-    if (fragment.needsScopeComment) {
-      return `<%== bf->scope_comment %>${children}<%== bf->scope_comment_end %>`;
-    }
-    return children;
-  }
-  renderSlot(_slot) {
-    return `<%= content %>`;
-  }
-  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}`;
-  }
-  elementAttrEmitter = {
-    emitLiteral: (value, name) => `${name}="${escapeHtml(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) && !this.loopBoundNames.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) && !this.loopBoundNames.has(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;
-    }
-    const args = entries.flatMap((e) => [
-      `'${e.cssKey.replace(/[\\']/g, (m) => `\\${m}`)}'`,
-      e.kind === "literal" ? `'${e.value.replace(/[\\']/g, (m) => `\\${m}`)}'` : this.convertExpressionToPerl(e.expr)
-    ]);
-    return `<%== bf->style_object(${args.join(", ")}) %>`;
-  }
-  renderAttributes(element) {
-    const parts = [];
-    for (const attr of element.attrs) {
-      if (attr.clientOnly)
-        continue;
-      if (isDangerousInnerHtmlAttr(attr))
-        continue;
-      let attrName;
-      if (attr.name === "className")
-        attrName = "class";
-      else if (attr.name === "key") {
-        const depth = this.currentLoopKeyDepth;
-        attrName = depth > 0 ? `data-key-${depth}` : "data-key";
-      } else
-        attrName = attr.name;
-      const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, attrName);
-      if (lowered)
-        parts.push(lowered);
-    }
-    return parts.length > 0 ? " " + parts.join(" ") : "";
-  }
-  renderScopeMarker(_instanceIdExpr) {
-    return `bf-s="<%= bf->scope_attr %>" <%== bf->hydration_attrs %> <%== bf->props_attr %>`;
-  }
-  renderSlotMarker(slotId) {
-    return `${BF_SLOT}="${slotId}"`;
-  }
-  renderCondMarker(condId) {
-    return `${BF_COND}="${condId}"`;
-  }
-  renderPerlFilterExpr(expr, param, localVarMap = new Map) {
-    return emitParsedExpr2(expr, new MojoFilterEmitter(param, localVarMap, (n) => this._isStringValueName(n), (message, reason) => this._recordExprBF101(message, reason)));
-  }
-  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(" . ");
-  }
-  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(" . ")})`;
-  }
-  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;
-  }
-  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)
-    };
-  }
-  get spreadCtx() {
-    return {
-      componentName: this.componentName,
-      errors: this.errors,
-      localConstants: this.localConstants,
-      propsParams: this.propsParams,
-      convertExpressionToPerl: (e, preParsed) => this.convertExpressionToPerl(e, preParsed)
-    };
-  }
-  get memoCtx() {
-    return { convertExpressionToPerl: (e, preParsed) => this.convertExpressionToPerl(e, preParsed) };
-  }
-  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(", ")})`;
-        }
-        if (node?.kind === "helper-call" && isValidHelperId(node.helper)) {
-          const argsX = node.args.map((a) => this.renderParsedExprToPerl(a));
-          return `bf->${node.helper}(${argsX.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);
-  }
-  renderParsedExprToPerl(expr) {
-    return emitParsedExpr2(expr, new MojoTopLevelEmitter(this.emitCtx));
-  }
-  _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;
-// src/build.ts
-function createConfig(options = {}) {
-  return {
-    adapter: new MojoAdapter(options.adapterOptions),
-    paths: options.paths,
-    components: options.components,
-    outDir: options.outDir,
-    minify: options.minify,
-    contentHash: options.contentHash,
-    externals: options.externals,
-    externalsBasePath: options.externalsBasePath,
-    bundleEntries: options.bundleEntries,
-    localImportPrefixes: options.localImportPrefixes,
-    outputLayout: options.outputLayout ?? {
-      templates: "templates",
-      clientJs: "client",
-      runtime: "client"
-    },
-    postBuild: options.postBuild
-  };
-}
-export {
-  createConfig
-};