@barefootjs/mojolicious 0.1.0

package/dist/adapter/index.js

@@ -0,0 +1,1143 @@
+// src/adapter/mojo-adapter.ts
+import {
+  BaseAdapter,
+  isBooleanAttr,
+  parseExpression as parseExpression2,
+  isSupported,
+  identifierPath,
+  stringifyParsedExpr,
+  emitParsedExpr,
+  emitIRNode,
+  emitAttrValue
+} 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-checked",
+  "aria-pressed"
+]);
+function isAriaBooleanAttr(name) {
+  return ARIA_BOOLEAN_ATTRS.has(name);
+}
+
+// src/adapter/mojo-adapter.ts
+import { BF_SLOT, BF_COND } from "@barefootjs/shared";
+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]})` }
+};
+var PRIMITIVE_SUBSTRING_RE = new RegExp(Object.keys(MOJO_TEMPLATE_PRIMITIVES).map((k) => k.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|"));
+var MOJO_PRIMITIVE_EMIT_MAP = Object.fromEntries(Object.entries(MOJO_TEMPLATE_PRIMITIVES).map(([k, v]) => [k, v.emit]));
+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;
+}
+
+class MojoAdapter extends BaseAdapter {
+  name = "mojolicious";
+  extension = ".html.ep";
+  templatesPerComponent = true;
+  templatePrimitives = MOJO_PRIMITIVE_EMIT_MAP;
+  componentName = "";
+  options;
+  errors = [];
+  inLoop = false;
+  higherOrderInFlight = new Set;
+  propsObjectName = null;
+  propsParams = [];
+  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;
+    this.propsParams = ir.metadata.propsParams.map((p) => ({ name: p.name }));
+    this.errors = [];
+    this.higherOrderInFlight = new Set;
+    this.childrenCaptureCounter = 0;
+    if (!options?.siblingTemplatesRegistered) {
+      this.checkImportedLoopChildComponents(ir);
+    }
+    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 template = `${scriptReg}${templateBody}
+`;
+    if (this.errors.length > 0) {
+      ir.errors.push(...this.errors);
+    }
+    const sections = {
+      imports: "",
+      types: "",
+      component: template,
+      defaultExport: ""
+    };
+    return {
+      template,
+      sections,
+      extension: this.extension
+    };
+  }
+  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(`
+`);
+  }
+  hasClientInteractivity(ir) {
+    return ir.metadata.signals.length > 0 || ir.metadata.effects.length > 0 || ir.metadata.onMounts.length > 0 || (ir.metadata.clientAnalysis?.needsInit ?? false);
+  }
+  renderNode(node) {
+    return emitIRNode(node, this, {});
+  }
+  emitElement(node, _ctx, _emit) {
+    return this.renderElement(node);
+  }
+  emitText(node) {
+    return 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) {
+    return this.renderChildren(node.children);
+  }
+  emitAsync(node, _ctx, _emit) {
+    return this.renderAsync(node);
+  }
+  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("")}`;
+    }
+    if (element.slotId) {
+      hydrationAttrs += ` ${this.renderSlotMarker(element.slotId)}`;
+    }
+    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}") %>`;
+      }
+      return "";
+    }
+    const perlExpr = this.convertExpressionToPerl(expr.expr);
+    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}") %>`;
+  }
+  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);
+      }
+    }
+    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:
+` + `  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);
+  }
+  renderLoop(loop) {
+    if (loop.clientOnly)
+      return "";
+    if (loop.paramBindings && loop.paramBindings.length > 0) {
+      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.`
+        }
+      });
+    }
+    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.index ? `$${loop.index}` : "$_i";
+    const prevInLoop = this.inLoop;
+    this.inLoop = true;
+    const children = this.renderChildren(loop.children);
+    this.inLoop = prevInLoop;
+    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}}) {`);
+    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);
+    }
+    lines.push(`% }`);
+    lines.push(`<%== bf->comment("/loop:${loop.markerId}") %>`);
+    return lines.join(`
+`);
+  }
+  componentPropEmitter = {
+    emitLiteral: (value, name) => `${name} => '${value.value}'`,
+    emitExpression: (value, name) => {
+      if (value.parts) {
+        return `${name} => ${this.convertTemplateLiteralPartsToPerl(value.parts)}`;
+      }
+      return `${name} => ${this.convertExpressionToPerl(value.expr)}`;
+    },
+    emitSpread: (value) => {
+      const perlExpr = this.convertExpressionToPerl(value.expr);
+      return perlExpr.startsWith("%") ? perlExpr : `%{${perlExpr}}`;
+    },
+    emitTemplate: (value, name) => `${name} => ${this.convertTemplateLiteralPartsToPerl(value.parts)}`,
+    emitBooleanAttr: (_value, name) => `${name} => 1`,
+    emitBooleanShorthand: (_value, name) => `${name} => 1`,
+    emitJsxChildren: () => ""
+  };
+  renderComponent(comp) {
+    const propParts = [];
+    for (const p of comp.props) {
+      if (p.name.match(/^on[A-Z]/) && 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 childrenBody = this.renderChildren(effectiveChildren);
+      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}) %>`;
+  }
+  childrenCaptureCounter = 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}`;
+    }
+    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}="${value.value}"`,
+    emitExpression: (value, name) => {
+      if (this.refuseUnsupportedAttrExpression(value.expr, name)) {
+        return "";
+      }
+      if (isBooleanAttr(name) || value.presenceOrUndefined) {
+        return `<%= ${this.convertExpressionToPerl(value.expr)} ? '${name}' : '' %>`;
+      }
+      const perl = this.convertExpressionToPerl(value.expr);
+      if (isBooleanResultExpr(value.expr) || isAriaBooleanAttr(name)) {
+        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 perlExpr = this.convertExpressionToPerl(value.expr);
+      return `<%== bf->spread_attrs(${perlExpr}) %>`;
+    },
+    emitBooleanShorthand: () => "",
+    emitJsxChildren: () => ""
+  };
+  renderAttributes(element) {
+    const parts = [];
+    for (const attr of element.attrs) {
+      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(" ") : "";
+  }
+  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 emitParsedExpr(expr, new MojoFilterEmitter(param, localVarMap));
+  }
+  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;
+  }
+  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})`;
+  }
+  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(" && ")})`;
+  }
+  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;
+  }
+  convertExpressionToPerl(expr) {
+    if (/\.\s*(?:filter|every|some|reduce|reduceRight|forEach|flatMap|flat|findLast|findLastIndex)\s*\(/.test(expr)) {
+      return this.convertHigherOrderExpr(expr);
+    }
+    if (/\.\s*(?:includes|indexOf|lastIndexOf|at|concat|slice|reverse|toReversed|toLowerCase|toUpperCase|trim)\s*\(/.test(expr)) {
+      return this.convertHigherOrderExpr(expr);
+    }
+    if (/\.\s*join\s*\(/.test(expr)) {
+      return this.convertHigherOrderExpr(expr);
+    }
+    const mojoOnlyMatch = /\.\s*(?<method>find|findIndex)\s*\(/.exec(expr);
+    if (mojoOnlyMatch) {
+      const methodName = mojoOnlyMatch.groups.method;
+      this.errors.push({
+        code: "BF101",
+        severity: "error",
+        message: `Mojo adapter has not lowered Array.prototype.${methodName} yet: ${expr.trim()}`,
+        loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+        suggestion: {
+          message: `Options:
+1. Use /* @client */ for client-side evaluation
+2. Pre-compute the value in Perl`
+        }
+      });
+      return "''";
+    }
+    expr = this.rewriteTemplatePrimitives(expr);
+    let result = expr.replace(/\b([a-z_]\w*)\(\)/g, (_, name) => `$${name}`);
+    result = result.replace(/\bprops\.(\w+)/g, (_, prop) => `$${prop}`);
+    result = result.replace(/(?<!\$)\b([a-z_]\w*)\.(\w+)/g, (match, obj, field) => {
+      if (match.startsWith("$"))
+        return match;
+      return `$${obj}->{${field}}`;
+    });
+    result = result.replace(/\$(\w+)\.(\w+)/g, (_, obj, field) => `$${obj}->{${field}}`);
+    result = result.replace(/\}->\{(\w+)\}\.(\w+)/g, (_, f1, f2) => `}->{${f1}}->{${f2}}`);
+    result = result.replace(/\$(\w+)->\{length\}/g, (_, arr) => `scalar(@{$${arr}})`);
+    result = result.replace(/\?\?/g, "//");
+    result = result.replace(/\s*===\s*(['"])/g, " eq $1");
+    result = result.replace(/\s*!==\s*(['"])/g, " ne $1");
+    result = result.replace(/(['"])\s*===\s*/g, "$1 eq ");
+    result = result.replace(/(['"])\s*!==\s*/g, "$1 ne ");
+    result = result.replace(/===/g, "==");
+    result = result.replace(/!==/g, "!=");
+    result = result.replace(/`([^`]*)`/g, (_, content) => {
+      const perlStr = content.replace(/\$\{([^}]+)\}/g, (_2, e) => `${this.convertExpressionToPerl(e)}`);
+      return `"${perlStr}"`;
+    });
+    if (/^[a-z_]\w*$/i.test(result) && !result.startsWith("$")) {
+      result = `$${result}`;
+    }
+    return result;
+  }
+  rewriteTemplatePrimitives(expr) {
+    if (!PRIMITIVE_SUBSTRING_RE.test(expr))
+      return expr;
+    const parsed = parseExpression2(expr);
+    if (parsed.kind === "unsupported")
+      return expr;
+    let mutated = false;
+    const walk = (n) => {
+      if (n.kind === "call") {
+        const path = identifierPath(n.callee);
+        const spec = path ? MOJO_TEMPLATE_PRIMITIVES[path] : undefined;
+        if (path && spec) {
+          if (n.args.length !== spec.arity) {
+            this.errors.push({
+              code: "BF101",
+              severity: "error",
+              message: `templatePrimitive '${path}' expects ${spec.arity} arg(s), got ${n.args.length}`,
+              loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+              suggestion: {
+                message: `Call '${path}' with exactly ${spec.arity} argument(s), or wrap the JSX expression in /* @client */ to defer evaluation.`
+              }
+            });
+            return { kind: "call", callee: walk(n.callee), args: n.args.map(walk) };
+          }
+          const renderedArgs = n.args.map((a) => this.convertExpressionToPerl(stringifyParsedExpr(walk(a))));
+          mutated = true;
+          return { kind: "identifier", name: spec.emit(renderedArgs) };
+        }
+      }
+      switch (n.kind) {
+        case "call":
+          return { kind: "call", callee: walk(n.callee), args: n.args.map(walk) };
+        case "member":
+          return { kind: "member", object: walk(n.object), property: n.property, computed: n.computed };
+        case "binary":
+          return { kind: "binary", op: n.op, left: walk(n.left), right: walk(n.right) };
+        case "unary":
+          return { kind: "unary", op: n.op, argument: walk(n.argument) };
+        case "logical":
+          return { kind: "logical", op: n.op, left: walk(n.left), right: walk(n.right) };
+        case "conditional":
+          return { kind: "conditional", test: walk(n.test), consequent: walk(n.consequent), alternate: walk(n.alternate) };
+        default:
+          return n;
+      }
+    };
+    const transformed = walk(parsed);
+    if (!mutated)
+      return expr;
+    return stringifyParsedExpr(transformed);
+  }
+  convertHigherOrderExpr(expr) {
+    if (this.higherOrderInFlight.has(expr)) {
+      this.errors.push({
+        code: "BF101",
+        severity: "error",
+        message: `Cannot lower higher-order chain to Embedded Perl: ${expr.trim()}`,
+        loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+        suggestion: {
+          message: "The Mojo adapter cannot lower this `.filter()` / `.every()` / `.some()` chain — typically because the array source is a JS array literal or a non-signal expression the AST classifier doesn't recognise. Move the expression into a `'use client'` component (so hydration computes it client-side), or rewrite it to operate on a signal getter or a prop directly."
+        }
+      });
+      return "''";
+    }
+    this.higherOrderInFlight.add(expr);
+    try {
+      const parsed = parseExpression2(expr);
+      const support = isSupported(parsed);
+      if (!support.supported) {
+        this.errors.push({
+          code: "BF101",
+          severity: "error",
+          message: `Cannot lower higher-order chain to Embedded Perl: ${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);
+    } finally {
+      this.higherOrderInFlight.delete(expr);
+    }
+  }
+  renderParsedExprToPerl(expr) {
+    return emitParsedExpr(expr, new MojoTopLevelEmitter(this));
+  }
+  _convertExpressionToPerlPublic(raw) {
+    return this.convertExpressionToPerl(raw);
+  }
+  _renderPerlFilterExprPublic(expr, param) {
+    return this.renderPerlFilterExpr(expr, param);
+  }
+}
+function renderArrayMethod(method, object, args, emit) {
+  switch (method) {
+    case "join": {
+      const obj = emit(object);
+      const sep = 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 = emit(args[0]);
+      return `bf->at(${obj}, ${idx})`;
+    }
+    case "concat": {
+      const a = emit(object);
+      const b = emit(args[0]);
+      return `bf->concat(${a}, ${b})`;
+    }
+    case "slice": {
+      const recv = emit(object);
+      const start = emit(args[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})`;
+    }
+    default: {
+      const _exhaustive = method;
+      throw new Error(`renderArrayMethod: unhandled ArrayMethod '${_exhaustive}'`);
+    }
+  }
+}
+function perlIdentifierFromMarkerId(markerId) {
+  return markerId.replace(/[^a-zA-Z0-9]/g, (ch) => ch === "_" ? "__" : `_x${ch.charCodeAt(0).toString(16)}`);
+}
+function renderSortMethod(recv, c) {
+  const keyEntry = c.key.kind === "self" ? `key_kind => 'self'` : `key_kind => 'field', key => '${c.key.field}'`;
+  return `bf->sort(${recv}, { ${keyEntry}, compare_type => '${c.type}', direction => '${c.direction}' })`;
+}
+
+class MojoFilterEmitter {
+  param;
+  localVarMap;
+  constructor(param, localVarMap) {
+    this.param = param;
+    this.localVarMap = localVarMap;
+  }
+  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)}})`;
+    }
+    return `${emit(object)}->{${property}}`;
+  }
+  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 = emit(left);
+    const r = emit(right);
+    if ((op === "===" || op === "==") && right.kind === "literal" && right.literalType === "string") {
+      return `${l} eq ${r}`;
+    }
+    if ((op === "!==" || op === "!=") && right.kind === "literal" && right.literalType === "string") {
+      return `${l} ne ${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})`;
+  }
+  higherOrder(method, object, param, predicate, emit) {
+    const arrayExpr = emit(object);
+    const predBody = emitParsedExpr(predicate, new MojoFilterEmitter(param, this.localVarMap));
+    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(", ")}]`;
+  }
+  arrayMethod(method, object, args, emit) {
+    return renderArrayMethod(method, object, args, emit);
+  }
+  sortMethod(_method, object, comparator, emit) {
+    return renderSortMethod(emit(object), comparator);
+  }
+  conditional(_test, _consequent, _alternate) {
+    return "1";
+  }
+  templateLiteral(_parts) {
+    return "1";
+  }
+  arrowFn(_param, _body) {
+    return "1";
+  }
+  unsupported(_raw, _reason) {
+    return "1";
+  }
+}
+
+class MojoTopLevelEmitter {
+  adapter;
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  identifier(name) {
+    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) {
+    const obj = emit(object);
+    if (property === "length")
+      return `scalar(@{${obj}})`;
+    return `${obj}->{${property}}`;
+  }
+  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 === "!")
+      return `!${arg}`;
+    if (op === "-")
+      return `-${arg}`;
+    return arg;
+  }
+  binary(op, left, right, emit) {
+    const l = emit(left);
+    const r = emit(right);
+    if ((op === "===" || op === "==") && right.kind === "literal" && right.literalType === "string") {
+      return `${l} eq ${r}`;
+    }
+    if ((op === "!==" || op === "!=") && right.kind === "literal" && right.literalType === "string") {
+      return `${l} ne ${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})`;
+  }
+  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}})`;
+    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);
+  }
+  conditional(test, consequent, alternate, emit) {
+    return `(${emit(test)} ? ${emit(consequent)} : ${emit(alternate)})`;
+  }
+  templateLiteral(_parts) {
+    return "";
+  }
+  arrowFn(_param, _body) {
+    return "";
+  }
+  unsupported(raw, _reason) {
+    return this.adapter._convertExpressionToPerlPublic(raw);
+  }
+}
+var mojoAdapter = new MojoAdapter;
+export {
+  mojoAdapter,
+  MojoAdapter
+};