@barefootjs/xslate 0.8.0

package/dist/build.js

@@ -0,0 +1,1224 @@
+// src/adapter/xslate-adapter.ts
+import {
+  BaseAdapter,
+  isBooleanAttr,
+  parseExpression as parseExpression2,
+  isSupported,
+  identifierPath,
+  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/xslate-adapter.ts
+import { BF_SLOT, BF_COND } from "@barefootjs/shared";
+var XSLATE_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 XSLATE_PRIMITIVE_EMIT_MAP = Object.fromEntries(Object.entries(XSLATE_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 XslateAdapter extends BaseAdapter {
+  name = "xslate";
+  extension = ".tx";
+  templatesPerComponent = true;
+  importMapInjection = "html-snippet";
+  templatePrimitives = XSLATE_PRIMITIVE_EMIT_MAP;
+  componentName = "";
+  options;
+  errors = [];
+  inLoop = false;
+  propsObjectName = null;
+  propsParams = [];
+  stringValueNames = 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;
+    this.propsParams = ir.metadata.propsParams.map((p) => ({ name: p.name }));
+    this.stringValueNames = new Set;
+    for (const s of ir.metadata.signals) {
+      if (isStringTypeInfo(s.type) || isBareStringLiteral(s.initialValue)) {
+        this.stringValueNames.add(s.getter);
+      }
+    }
+    for (const p of ir.metadata.propsParams) {
+      if (isStringTypeInfo(p.type))
+        this.stringValueNames.add(p.name);
+    }
+    this.errors = [];
+    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(`: my $_bf_reg0 = $bf.register_script('${runtimePath}');`);
+    lines.push(`: my $_bf_reg1 = $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}") | mark_raw :>`;
+      }
+      return "";
+    }
+    const perlExpr = this.convertExpressionToKolon(expr.expr);
+    if (expr.slotId) {
+      return `<: $bf.text_start("${expr.slotId}") | mark_raw :><: ${perlExpr} :><: $bf.text_end() | mark_raw :>`;
+    }
+    return `<: ${perlExpr} :>`;
+  }
+  renderConditional(cond) {
+    if (cond.clientOnly && cond.slotId) {
+      return `<: $bf.comment("cond-start:${cond.slotId}") | mark_raw :><: $bf.comment("cond-end:${cond.slotId}") | mark_raw :>`;
+    }
+    const condition = this.convertExpressionToKolon(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}") | mark_raw :>${inner}<: $bf.comment("cond-end:${cond.slotId}") | mark_raw :>`;
+    } else if (markedFalse) {
+      result = `
+: if (${condition}) {
+${markedTrue}
+: } else {
+${markedFalse}
+: }
+`;
+    } else if (cond.slotId) {
+      result = `<: $bf.comment("cond-start:${cond.slotId}") | mark_raw :>
+: if (${condition}) {
+${whenTrue}
+: }
+<: $bf.comment("cond-end:${cond.slotId}") | mark_raw :>`;
+    } 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}") | mark_raw :>${content}<: $bf.comment("cond-end:${condId}") | mark_raw :>`;
+  }
+  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 Xslate 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 Xslate 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 Xslate adapter cannot lower — Kolon \`for LIST -> $item\` binds a single scalar and can't unpack a tuple.`,
+        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.convertExpressionToKolon(loop.array);
+    let array = rawArray;
+    if (loop.sortComparator) {
+      array = renderSortMethod(rawArray, loop.sortComparator);
+    }
+    const param = loop.param;
+    const renderedChildren = this.renderChildren(loop.children);
+    const loopVar = loop.iterationShape === "keys" ? "__bf_item" : param;
+    const indexLocalLines = [];
+    if (loop.iterationShape === "keys") {
+      indexLocalLines.push(`: my $${param} = $~${loopVar}.index;`);
+    } else if (loop.index) {
+      indexLocalLines.push(`: my $${loop.index} = $~${loopVar}.index;`);
+    }
+    const prevInLoop = this.inLoop;
+    this.inLoop = true;
+    const childrenUnderLoop = this.renderChildren(loop.children);
+    this.inLoop = prevInLoop;
+    const bodyChildren = loop.bodyIsItemConditional && loop.key ? `<: $bf.comment("loop-i:" ~ ${this.convertExpressionToKolon(loop.key)}) | mark_raw :>
+${childrenUnderLoop}` : childrenUnderLoop;
+    const lines = [];
+    lines.push(`<: $bf.comment("loop:${loop.markerId}") | mark_raw :>`);
+    lines.push(`: for ${array} -> $${loopVar} {`);
+    for (const il of indexLocalLines)
+      lines.push(il);
+    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.renderKolonFilterExpr(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(bodyChildren);
+      lines.push(`: }`);
+    } else {
+      lines.push(bodyChildren);
+    }
+    lines.push(`: }`);
+    lines.push(`<: $bf.comment("/loop:${loop.markerId}") | mark_raw :>`);
+    return lines.join(`
+`);
+  }
+  componentPropEmitter = {
+    emitLiteral: (value, name) => `${name} => '${value.value}'`,
+    emitExpression: (value, name) => {
+      if (value.parts) {
+        return `${name} => ${this.convertTemplateLiteralPartsToKolon(value.parts)}`;
+      }
+      return `${name} => ${this.convertExpressionToKolon(value.expr)}`;
+    },
+    emitSpread: (value) => {
+      return this.convertExpressionToKolon(value.expr);
+    },
+    emitTemplate: (value, name) => `${name} => ${this.convertTemplateLiteralPartsToKolon(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;
+      if (p.value.kind === "spread") {
+        const trimmed = p.value.expr.trim();
+        if (this.propsObjectName && this.propsObjectName === trimmed) {
+          for (const pp of this.propsParams) {
+            propParts.push(`${pp.name} => $${pp.name}`);
+          }
+          continue;
+        }
+        this.errors.push({
+          code: "BF101",
+          severity: "error",
+          message: `Spread props (\`{...${trimmed}}\`) on a child component cannot be lowered to Kolon — Kolon hashref method args can't splat a runtime hash into named entries.`,
+          loc: comp.loc ?? { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+          suggestion: {
+            message: "Pass the child component its props explicitly rather than spreading a runtime object."
+          }
+        });
+        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 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 macroName = `bf_children_${comp.slotId ?? "c" + this.childrenCaptureCounter++}`;
+      const childrenEntry = `children => ${macroName}()`;
+      const allParts = [...propParts, childrenEntry];
+      return `<: macro ${macroName} -> () { :>${childrenBody}<: } :><: $bf.render_child('${tplName}', { ${allParts.join(", ")} }) | mark_raw :>`;
+    }
+    const hashEntries = propParts.length > 0 ? `, { ${propParts.join(", ")} }` : "";
+    return `<: $bf.render_child('${tplName}'${hashEntries}) | mark_raw :>`;
+  }
+  childrenCaptureCounter = 0;
+  toTemplateName(componentName) {
+    return componentName.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+  }
+  renderIfStatement(ifStmt) {
+    const condition = this.convertExpressionToKolon(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() | mark_raw :>${children}`;
+    }
+    return children;
+  }
+  renderSlot(_slot) {
+    return `<: $children | mark_raw :>`;
+  }
+  renderAsync(node) {
+    const fallback = this.renderNode(node.fallback);
+    const children = this.renderChildren(node.children);
+    const macroName = `bf_async_fallback_${node.id}`;
+    return `<: macro ${macroName} -> () { :>${fallback}<: } :><: $bf.async_boundary('${node.id}', ${macroName}()) | mark_raw :>
+${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.convertExpressionToKolon(value.expr)} ? '${name}' : '' :>`;
+      }
+      const perl = this.convertExpressionToKolon(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.convertTemplateLiteralPartsToKolon(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(", ")}}) | mark_raw :>`;
+      }
+      const perlExpr = this.convertExpressionToKolon(value.expr);
+      return `<: $bf.spread_attrs(${perlExpr}) | mark_raw :>`;
+    },
+    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() | mark_raw :> <: $bf.props_attr() | mark_raw :>`;
+  }
+  renderSlotMarker(slotId) {
+    return `${BF_SLOT}="${slotId}"`;
+  }
+  renderCondMarker(condId) {
+    return `${BF_COND}="${condId}"`;
+  }
+  renderKolonFilterExpr(expr, param, localVarMap = new Map) {
+    return emitParsedExpr(expr, new XslateFilterEmitter(param, localVarMap, (n) => this._isStringValueName(n)));
+  }
+  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.renderKolonFilterExpr(path.result, param, localVarMap);
+    }
+    const condPart = this.renderConditionsAnd(path.conditions, param, localVarMap);
+    const resultPart = this.renderKolonFilterExpr(path.result, param, localVarMap);
+    return `(${condPart} && ${resultPart})`;
+  }
+  renderConditionsAnd(conditions, param, localVarMap) {
+    if (conditions.length === 0)
+      return "1";
+    if (conditions.length === 1)
+      return this.renderKolonFilterExpr(conditions[0], param, localVarMap);
+    const parts = conditions.map((c) => this.renderKolonFilterExpr(c, param, localVarMap));
+    return `(${parts.join(" && ")})`;
+  }
+  convertTemplateLiteralPartsToKolon(literalParts) {
+    const parts = [];
+    for (const part of literalParts) {
+      if (part.type === "string") {
+        parts.push(this.substituteJsInterpolationsToKolon(part.value));
+      } else if (part.type === "ternary") {
+        const cond = this.convertExpressionToKolon(part.condition);
+        parts.push(`(${cond} ? '${part.whenTrue}' : '${part.whenFalse}')`);
+      } else if (part.type === "lookup") {
+        const keyExpr = this.convertExpressionToKolon(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(" ~ ");
+  }
+  substituteJsInterpolationsToKolon(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.convertExpressionToKolon(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 Xslate adapter cannot lower JS object literals or tagged-template-literal expressions into Kolon. 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;
+  }
+  convertExpressionToKolon(expr) {
+    const trimmed = expr.trim();
+    if (trimmed === "")
+      return "''";
+    const parsed = parseExpression2(trimmed);
+    const support = isSupported(parsed);
+    if (!support.supported) {
+      this.errors.push({
+        code: "BF101",
+        severity: "error",
+        message: `Expression not supported: ${trimmed}`,
+        loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
+        suggestion: {
+          message: support.reason ? `${support.reason}
+
+Options:
+1. Use /* @client */ for client-side evaluation
+2. Pre-compute the value in the backend` : `Options:
+1. Use /* @client */ for client-side evaluation
+2. Pre-compute the value in the backend`
+        }
+      });
+      return "''";
+    }
+    return this.renderParsedExprToKolon(parsed);
+  }
+  renderParsedExprToKolon(expr) {
+    return emitParsedExpr(expr, new XslateTopLevelEmitter(this));
+  }
+  _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 the backend` : `Options:
+1. Use /* @client */ for client-side evaluation
+2. Pre-compute the value in the backend`
+      }
+    });
+  }
+  _renderKolonFilterExprPublic(expr, param) {
+    return this.renderKolonFilterExpr(expr, param);
+  }
+}
+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 `$bf.lc(${recv})`;
+    }
+    case "toUpperCase": {
+      const recv = emit(object);
+      return `$bf.uc(${recv})`;
+    }
+    case "trim": {
+      const recv = emit(object);
+      return `$bf.trim(${recv})`;
+    }
+    case "split": {
+      const recv = emit(object);
+      if (args.length === 0) {
+        return `$bf.split(${recv})`;
+      }
+      const sep = emit(args[0]);
+      if (args.length === 1) {
+        return `$bf.split(${recv}, ${sep})`;
+      }
+      const limit = emit(args[1]);
+      return `$bf.split(${recv}, ${sep}, ${limit})`;
+    }
+    case "startsWith":
+    case "endsWith": {
+      const fn = method === "startsWith" ? "starts_with" : "ends_with";
+      const recv = emit(object);
+      const arg = emit(args[0]);
+      if (args.length >= 2) {
+        return `$bf.${fn}(${recv}, ${arg}, ${emit(args[1])})`;
+      }
+      return `$bf.${fn}(${recv}, ${arg})`;
+    }
+    case "replace": {
+      const recv = emit(object);
+      const oldS = emit(args[0]);
+      const newS = emit(args[1]);
+      return `$bf.replace(${recv}, ${oldS}, ${newS})`;
+    }
+    case "repeat": {
+      const recv = emit(object);
+      const count = args.length === 0 ? "0" : emit(args[0]);
+      return `$bf.repeat(${recv}, ${count})`;
+    }
+    case "padStart":
+    case "padEnd": {
+      const fn = method === "padStart" ? "pad_start" : "pad_end";
+      const recv = emit(object);
+      if (args.length === 0) {
+        return `$bf.${fn}(${recv}, 0)`;
+      }
+      const target = emit(args[0]);
+      if (args.length === 1) {
+        return `$bf.${fn}(${recv}, ${target})`;
+      }
+      const pad = emit(args[1]);
+      return `$bf.${fn}(${recv}, ${target}, ${pad})`;
+    }
+    default: {
+      const _exhaustive = method;
+      throw new Error(`renderArrayMethod: unhandled ArrayMethod '${_exhaustive}'`);
+    }
+  }
+}
+function renderSortMethod(recv, c) {
+  const keyHashes = c.keys.map((k) => {
+    const keyEntry = k.key.kind === "self" ? `key_kind => 'self'` : `key_kind => 'field', key => '${k.key.field}'`;
+    return `{ ${keyEntry}, compare_type => '${k.type}', direction => '${k.direction}' }`;
+  });
+  return `$bf.sort(${recv}, { keys => [${keyHashes.join(", ")}] })`;
+}
+function renderReduceMethod(recv, op, direction) {
+  const keyEntry = op.key.kind === "self" ? `key_kind => 'self'` : `key_kind => 'field', key => '${op.key.field}'`;
+  const init = op.type === "string" ? `'${op.init.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'` : op.init;
+  return `$bf.reduce(${recv}, { op => '${op.op}', ${keyEntry}, type => '${op.type}', init => ${init}, direction => '${direction}' })`;
+}
+function renderFlatMethod(recv, depth) {
+  const d = depth === "infinity" ? -1 : depth;
+  return `$bf.flat(${recv}, ${d})`;
+}
+function renderFlatMapMethod(recv, op) {
+  const proj = op.projection;
+  if (proj.kind === "tuple") {
+    const specs = proj.elements.map((l) => l.kind === "self" ? `['self', '']` : `['field', '${l.field}']`).join(", ");
+    return `$bf.flat_map_tuple(${recv}, ${specs})`;
+  }
+  if (proj.kind === "self")
+    return `$bf.flat_map(${recv}, 'self', '')`;
+  return `$bf.flat_map(${recv}, 'field', '${proj.field}')`;
+}
+function isStringTypeInfo(type) {
+  return type?.kind === "primitive" && type.primitive === "string";
+}
+function isBareStringLiteral(initialValue) {
+  if (!initialValue)
+    return false;
+  const v = initialValue.trim();
+  return v.startsWith("'") && v.endsWith("'") || v.startsWith('"') && v.endsWith('"');
+}
+function isStringTypedOperand(expr, isStringName) {
+  if (expr.kind === "literal" && expr.literalType === "string")
+    return true;
+  if (expr.kind === "call" && expr.callee.kind === "identifier" && expr.args.length === 0) {
+    return isStringName(expr.callee.name);
+  }
+  if (expr.kind === "member" && expr.object.kind === "identifier" && expr.object.name === "props") {
+    return isStringName(expr.property);
+  }
+  return false;
+}
+
+class XslateFilterEmitter {
+  param;
+  localVarMap;
+  isStringName;
+  constructor(param, localVarMap, isStringName = () => false) {
+    this.param = param;
+    this.localVarMap = localVarMap;
+    this.isStringName = isStringName;
+  }
+  identifier(name) {
+    if (name === this.param)
+      return `$${this.param}`;
+    const signal = this.localVarMap.get(name);
+    if (signal)
+      return `$${signal}`;
+    return `$${name}`;
+  }
+  literal(value, literalType) {
+    if (literalType === "string")
+      return `'${value}'`;
+    if (literalType === "boolean")
+      return value ? "1" : "0";
+    if (literalType === "null")
+      return "undef";
+    return String(value);
+  }
+  member(object, property, _computed, emit) {
+    if (property === "length") {
+      return `${emit(object)}.size()`;
+    }
+    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);
+    const isStr = (e) => isStringTypedOperand(e, this.isStringName);
+    const stringCmp = isStr(left) || isStr(right);
+    if ((op === "===" || op === "==") && stringCmp) {
+      return `${l} eq ${r}`;
+    }
+    if ((op === "!==" || op === "!=") && stringCmp) {
+      return `${l} ne ${r}`;
+    }
+    const opMap = {
+      "===": "==",
+      "!==": "!=",
+      ">": ">",
+      "<": "<",
+      ">=": ">=",
+      "<=": "<=",
+      "+": "+",
+      "-": "-",
+      "*": "*",
+      "/": "/"
+    };
+    return `${l} ${opMap[op] ?? op} ${r}`;
+  }
+  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) {
+    return emit(object);
+  }
+  arrayLiteral(elements, emit) {
+    return `[${elements.map(emit).join(", ")}]`;
+  }
+  arrayMethod(method, object, args, emit) {
+    return renderArrayMethod(method, object, args, emit);
+  }
+  sortMethod(_method, object, comparator, emit) {
+    return renderSortMethod(emit(object), comparator);
+  }
+  reduceMethod(method, object, reduceOp, emit) {
+    return renderReduceMethod(emit(object), reduceOp, method === "reduceRight" ? "right" : "left");
+  }
+  flatMethod(object, depth, emit) {
+    return renderFlatMethod(emit(object), depth);
+  }
+  flatMapMethod(object, op, emit) {
+    return renderFlatMapMethod(emit(object), op);
+  }
+  conditional(_test, _consequent, _alternate) {
+    return "1";
+  }
+  templateLiteral(_parts) {
+    return "1";
+  }
+  arrowFn(_param, _body) {
+    return "1";
+  }
+  unsupported(_raw, _reason) {
+    return "1";
+  }
+}
+
+class XslateTopLevelEmitter {
+  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) {
+    if (object.kind === "identifier" && object.name === "props") {
+      return `$${property}`;
+    }
+    const obj = emit(object);
+    if (property === "length")
+      return `${obj}.size()`;
+    return `${obj}.${property}`;
+  }
+  call(callee, args, emit) {
+    if (callee.kind === "identifier" && args.length === 0) {
+      return `$${callee.name}`;
+    }
+    const path = identifierPath(callee);
+    const spec = path ? XSLATE_TEMPLATE_PRIMITIVES[path] : undefined;
+    if (path && spec) {
+      if (args.length === spec.arity) {
+        return spec.emit(args.map(emit));
+      }
+      this.adapter._recordExprBF101(`templatePrimitive '${path}' expects ${spec.arity} arg(s), got ${args.length}`, `Call '${path}' with exactly ${spec.arity} argument(s).`);
+      return "''";
+    }
+    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);
+    const isStr = (e) => isStringTypedOperand(e, (n) => this.adapter._isStringValueName(n));
+    const stringCmp = isStr(left) || isStr(right);
+    if ((op === "===" || op === "==") && stringCmp) {
+      return `${l} eq ${r}`;
+    }
+    if ((op === "!==" || op === "!=") && stringCmp) {
+      return `${l} ne ${r}`;
+    }
+    const opMap = {
+      "===": "==",
+      "!==": "!=",
+      ">": ">",
+      "<": "<",
+      ">=": ">=",
+      "<=": "<=",
+      "+": "+",
+      "-": "-",
+      "*": "*"
+    };
+    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) {
+    if (method === "find" || method === "findIndex" || method === "findLast" || method === "findLastIndex") {
+      this.adapter._recordExprBF101(`Xslate adapter has not lowered Array.prototype.${method} yet`);
+      return "''";
+    }
+    if (method === "filter" || method === "every" || method === "some") {
+      this.adapter._recordExprBF101(`Xslate adapter does not lower a standalone Array.prototype.${method} yet ` + `(the .filter(...).map(...) loop form is supported). ` + `Use /* @client */ or precompute the value.`);
+      return "''";
+    }
+    return emit(object);
+  }
+  arrayLiteral(elements, emit) {
+    return `[${elements.map(emit).join(", ")}]`;
+  }
+  arrayMethod(method, object, args, emit) {
+    return renderArrayMethod(method, object, args, emit);
+  }
+  sortMethod(_method, object, comparator, emit) {
+    return renderSortMethod(emit(object), comparator);
+  }
+  reduceMethod(method, object, reduceOp, emit) {
+    return renderReduceMethod(emit(object), reduceOp, method === "reduceRight" ? "right" : "left");
+  }
+  flatMethod(object, depth, emit) {
+    return renderFlatMethod(emit(object), depth);
+  }
+  flatMapMethod(object, op, emit) {
+    return renderFlatMapMethod(emit(object), op);
+  }
+  conditional(test, consequent, alternate, emit) {
+    return `(${emit(test)} ? ${emit(consequent)} : ${emit(alternate)})`;
+  }
+  templateLiteral(parts, emit) {
+    const terms = [];
+    for (const part of parts) {
+      if (part.type === "string") {
+        if (part.value !== "") {
+          terms.push(`'${part.value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`);
+        }
+      } 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(" ~ ");
+  }
+  arrowFn(_param, _body) {
+    return "''";
+  }
+  unsupported(_raw, _reason) {
+    return "''";
+  }
+}
+var xslateAdapter = new XslateAdapter;
+// src/build.ts
+function createConfig(options = {}) {
+  return {
+    adapter: new XslateAdapter(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
+};