@barefootjs/xslate 0.15.2 → 0.17.0

package/dist/adapter/index.js

@@ -187291,25 +187291,23 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
 import {
   BaseAdapter,
   isBooleanAttr,
-  parseExpression as parseExpression2,
+  parseExpression as parseExpression3,
+  stringifyParsedExpr as stringifyParsedExpr2,
   exprToString,
   parseProviderObjectLiteral,
   parseStyleObjectEntries,
-  isSupported,
-  identifierPath,
+  isSupported as isSupported2,
   emitParsedExpr,
   emitIRNode,
   emitAttrValue,
   augmentInheritedPropAccesses,
-  parseRecordIndexAccess,
-  evalStringArrayJoin,
   collectModuleStringConsts,
-  extractArrowBodyExpression,
-  collectContextConsumers,
   isLowerableObjectRestDestructure,
   lookupStaticRecordLiteral,
   searchParamsLocalNames,
-  matchSearchParamsMethodCall
+  prepareLoweringMatchers,
+  queryHrefArgs,
+  sortComparatorFromArrow as sortComparatorFromArrow2
 } from "@barefootjs/jsx";
 
 // src/adapter/boolean-result.ts
@@ -187366,8 +187364,9 @@ function isAriaBooleanAttr(name) {
 }
 
 // src/adapter/xslate-adapter.ts
-var import_typescript = __toESM(require_typescript(), 1);
 import { BF_SLOT, BF_COND, BF_REGION } from "@barefootjs/shared";
+
+// src/adapter/lib/constants.ts
 var XSLATE_TEMPLATE_PRIMITIVES = {
   "JSON.stringify": { arity: 1, emit: (args) => `$bf.json(${args[0]})` },
   String: { arity: 1, emit: (args) => `$bf.string(${args[0]})` },
@@ -187377,12 +187376,16 @@ var XSLATE_TEMPLATE_PRIMITIVES = {
   "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]));
+
+// src/adapter/lib/kolon-naming.ts
 function escapeKolonSingleQuoted(s) {
   return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
 }
 function kolonHashKey(name) {
   return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : `'${escapeKolonSingleQuoted(name)}'`;
 }
+
+// src/adapter/lib/ir-scope.ts
 function resolveJsxChildrenProp(props) {
   const prop = props.find((p) => p.name === "children");
   if (!prop)
@@ -187422,1164 +187425,737 @@ function referencedVarsAreAvailable(expr, available) {
   return true;
 }
 
-class XslateAdapter extends BaseAdapter {
-  name = "xslate";
-  extension = ".tx";
-  templatesPerComponent = true;
-  importMapInjection = "html-snippet";
-  templatePrimitives = XSLATE_PRIMITIVE_EMIT_MAP;
-  componentName = "";
-  rootScopeNodes = new Set;
-  options;
-  errors = [];
-  inLoop = false;
-  propsObjectName = null;
-  propsParams = [];
-  booleanTypedProps = new Set;
-  stringValueNames = new Set;
-  moduleStringConsts = new Map;
-  _searchParamsLocals = new Set;
-  localConstants = [];
-  nullableOptionalProps = new Set;
-  constructor(options = {}) {
-    super();
-    this.options = {
-      clientJsBasePath: options.clientJsBasePath ?? "/static/components/",
-      barefootJsPath: options.barefootJsPath ?? "/static/components/barefoot.js"
-    };
-  }
-  generate(ir, options) {
-    this.componentName = ir.metadata.componentName;
-    this.propsObjectName = ir.metadata.propsObjectName ?? null;
-    augmentInheritedPropAccesses(ir);
-    this.propsParams = ir.metadata.propsParams.map((p) => ({ name: p.name }));
-    this.booleanTypedProps = new Set(ir.metadata.propsParams.filter((prop) => prop.type?.primitive === "boolean" || prop.type?.raw === "boolean").map((prop) => prop.name));
-    this.localConstants = ir.metadata.localConstants ?? [];
-    this.nullableOptionalProps = new Set(ir.metadata.propsParams.filter((p) => p.defaultValue === undefined && !p.isRest && p.type?.kind !== "primitive").map((p) => p.name));
-    this.stringValueNames = new Set;
-    for (const s of ir.metadata.signals) {
-      if (isStringTypeInfo(s.type) || isBareStringLiteral(s.initialValue)) {
-        this.stringValueNames.add(s.getter);
+// src/adapter/expr/array-method.ts
+import {
+  serializeParsedExpr,
+  freeVarsInBody
+} from "@barefootjs/jsx";
+function renderArrayMethod(method, object, args, emit) {
+  switch (method) {
+    case "join": {
+      const obj = emit(object);
+      const sep = args.length >= 1 ? emit(args[0]) : `','`;
+      return `$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})`;
     }
-    for (const p of ir.metadata.propsParams) {
-      if (isStringTypeInfo(p.type))
-        this.stringValueNames.add(p.name);
+    case "slice": {
+      const recv = emit(object);
+      const start = args.length >= 1 ? emit(args[0]) : "0";
+      const end = args.length >= 2 ? emit(args[1]) : "nil";
+      return `$bf.slice(${recv}, ${start}, ${end})`;
     }
-    this.moduleStringConsts = collectModuleStringConsts(ir.metadata.localConstants);
-    this._searchParamsLocals = searchParamsLocalNames(ir.metadata);
-    this.errors = [];
-    this.childrenCaptureCounter = 0;
-    if (!options?.siblingTemplatesRegistered) {
-      this.checkImportedLoopChildComponents(ir);
+    case "reverse":
+    case "toReversed": {
+      const recv = emit(object);
+      return `$bf.reverse(${recv})`;
     }
-    this.rootScopeNodes = collectRootScopeNodes(ir.root);
-    const templateBody = ir.root.type === "if-statement" ? this.renderIfStatement(ir.root) : this.renderNode(ir.root);
-    const scriptReg = options?.skipScriptRegistration ? "" : this.generateScriptRegistrations(ir, options?.scriptBaseName);
-    const ctxSeed = this.generateContextConsumerSeed(ir);
-    const memoSeed = this.generateDerivedMemoSeed(ir);
-    const template = `${scriptReg}${ctxSeed}${memoSeed}${templateBody}
-`;
-    if (this.errors.length > 0) {
-      ir.errors.push(...this.errors);
+    case "toLowerCase": {
+      const recv = emit(object);
+      return `$bf.lc(${recv})`;
     }
-    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) {
-    const value = this.providerValueKolon(node.valueProp);
-    const children = this.renderChildren(node.children);
-    const name = node.contextName;
-    return `<: $bf.provide_context('${name}', ${value}) :>` + children + `<: $bf.revoke_context('${name}') :>`;
-  }
-  providerValueKolon(valueProp) {
-    const v = valueProp.value;
-    if (v.kind === "literal") {
-      return typeof v.value === "string" ? `'${v.value.replace(/[\\']/g, (m) => `\\${m}`)}'` : String(v.value);
+    case "toUpperCase": {
+      const recv = emit(object);
+      return `$bf.uc(${recv})`;
     }
-    if (v.kind === "expression") {
-      const hashref = this.providerObjectLiteralKolon(v.expr);
-      if (hashref !== null)
-        return hashref;
-      return this.convertExpressionToKolon(v.expr);
+    case "trim": {
+      const recv = emit(object);
+      return `$bf.trim(${recv})`;
     }
-    if (v.kind === "template")
-      return this.convertTemplateLiteralPartsToKolon(v.parts);
-    return "nil";
-  }
-  providerObjectLiteralKolon(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} => nil`;
-      const src = m.kind === "getter" ? m.body : m.expr;
-      return `${key} => ${this.convertExpressionToKolon(src)}`;
-    });
-    return `{ ${entries.join(", ")} }`;
-  }
-  contextDefaultKolon(c) {
-    const d = c.defaultValue;
-    if (d === null || d === undefined)
-      return "nil";
-    if (typeof d === "string")
-      return `'${d.replace(/[\\']/g, (m) => `\\${m}`)}'`;
-    if (typeof d === "boolean")
-      return d ? "1" : "0";
-    return String(d);
-  }
-  generateContextConsumerSeed(ir) {
-    const consumers = collectContextConsumers(ir.metadata);
-    if (consumers.length === 0)
-      return "";
-    return consumers.map((c) => `: my $${c.localName} = $bf.use_context('${c.contextName}', ${this.contextDefaultKolon(c)});`).join(`
-`) + `
-`;
-  }
-  generateDerivedMemoSeed(ir) {
-    const memos = ir.metadata.memos ?? [];
-    const signals = ir.metadata.signals ?? [];
-    if (memos.length === 0 && signals.length === 0)
-      return "";
-    const available = new Set(ir.metadata.propsParams.map((p) => p.name));
-    const lines = [];
-    for (const signal of signals) {
-      const kolon = this.tryLowerToKolon(signal.initialValue, available);
-      const refsSelf = kolon !== null && new RegExp(`\\$${signal.getter}\\b`).test(kolon);
-      if (kolon !== null && !refsSelf)
-        lines.push(`: my $${signal.getter} = ${kolon};`);
-      available.add(signal.getter);
+    case "toFixed": {
+      const recv = emit(object);
+      const digits = args.length >= 1 ? emit(args[0]) : "0";
+      return `$bf.to_fixed(${recv}, ${digits})`;
     }
-    for (const memo of memos) {
-      const body = extractArrowBodyExpression(memo.computation);
-      if (body !== null) {
-        const kolon = this.tryLowerToKolon(body, available);
-        const refsSelf = kolon !== null && new RegExp(`\\$${memo.name}\\b`).test(kolon);
-        if (kolon !== null && !refsSelf)
-          lines.push(`: my $${memo.name} = ${kolon};`);
+    case "split": {
+      const recv = emit(object);
+      if (args.length === 0) {
+        return `$bf.split(${recv})`;
       }
-      available.add(memo.name);
-    }
-    return lines.length > 0 ? lines.join(`
-`) + `
-` : "";
-  }
-  tryLowerToKolon(expr, available) {
-    const trimmed = expr.trim();
-    if (!trimmed)
-      return null;
-    if (!isSupported(parseExpression2(trimmed)).supported)
-      return null;
-    const kolon = this.convertExpressionToKolon(trimmed);
-    if (kolon === "" || !/\$[A-Za-z_]\w*/.test(kolon))
-      return null;
-    return referencedVarsAreAvailable(kolon, available) ? kolon : null;
-  }
-  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("")}`;
+      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})`;
     }
-    if (this.rootScopeNodes.has(element) && element.needsScope) {
-      hydrationAttrs += ` <: $bf.data_key_attr() | mark_raw :>`;
+    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})`;
     }
-    if (element.slotId) {
-      hydrationAttrs += ` ${this.renderSlotMarker(element.slotId)}`;
+    case "replace": {
+      const recv = emit(object);
+      const oldS = emit(args[0]);
+      const newS = emit(args[1]);
+      return `$bf.replace(${recv}, ${oldS}, ${newS})`;
     }
-    if (element.regionId) {
-      hydrationAttrs += ` ${BF_REGION}="${element.regionId}"`;
+    case "repeat": {
+      const recv = emit(object);
+      const count = args.length === 0 ? "0" : emit(args[0]);
+      return `$bf.repeat(${recv}, ${count})`;
     }
-    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 :>`;
+    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)`;
       }
-      return "";
+      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})`;
     }
-    const perlExpr = this.convertExpressionToKolon(expr.expr);
-    if (expr.slotId) {
-      return `<: $bf.text_start("${expr.slotId}") | mark_raw :><: ${perlExpr} :><: $bf.text_end() | mark_raw :>`;
+    default: {
+      const _exhaustive = method;
+      throw new Error(`renderArrayMethod: unhandled ArrayMethod '${_exhaustive}'`);
     }
-    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;
+}
+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) {
+  const json = serializeParsedExpr(body);
+  if (json === null)
+    return null;
+  if (params.length < 2)
+    return null;
+  const [paramA, paramB] = params;
+  const env = emitEvalEnvArg(body, params, emit);
+  return `$bf.sort_eval(${recv}, '${escapePerlSingleQuote(json)}', '${paramA}', '${paramB}', ${env})`;
+}
+function renderReduceEval(recv, body, params, init, direction, emit) {
+  const json = serializeParsedExpr(body);
+  if (json === null)
+    return null;
+  if (init.kind !== "literal")
+    return null;
+  const initOut = init.literalType === "string" ? `'${escapePerlSingleQuote(String(init.value))}'` : init.literalType === "number" ? String(init.value) : null;
+  if (initOut === null)
+    return null;
+  if (params.length < 2)
+    return null;
+  const [paramAcc, paramItem] = params;
+  const env = emitEvalEnvArg(body, params, emit);
+  return `$bf.reduce_eval(${recv}, '${escapePerlSingleQuote(json)}', '${paramAcc}', '${paramItem}', ${initOut}, '${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 renderSortMethod(recv, c) {
+  const keyHashes = c.keys.map((k) => {
+    const keyEntry = k.key.kind === "self" ? `key_kind => 'self'` : `key_kind => 'field', key => '${k.key.field}'`;
+    return `{ ${keyEntry}, compare_type => '${k.type}', direction => '${k.direction}' }`;
+  });
+  return `$bf.sort(${recv}, { keys => [${keyHashes.join(", ")}] })`;
+}
+function renderFlatMethod(recv, depth) {
+  const d = depth === "infinity" ? -1 : depth;
+  return `$bf.flat(${recv}, ${d})`;
+}
+
+// src/adapter/expr/emitters.ts
+import {
+  identifierPath,
+  matchSearchParamsMethodCall,
+  sortComparatorFromArrow
+} from "@barefootjs/jsx";
+var PREDICATE_METHODS = new Set([
+  "filter",
+  "find",
+  "findIndex",
+  "findLast",
+  "findLastIndex",
+  "every",
+  "some"
+]);
+
+class XslateFilterEmitter {
+  param;
+  localVarMap;
+  isStringName;
+  constructor(param, localVarMap, isStringName = () => false) {
+    this.param = param;
+    this.localVarMap = localVarMap;
+    this.isStringName = isStringName;
   }
-  renderNodeOrNull(node) {
-    if (node.type === "expression" && (node.expr === "null" || node.expr === "undefined")) {
-      return null;
+  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 "nil";
+    return String(value);
+  }
+  member(object, property, _computed, emit) {
+    if (property === "length") {
+      return `$bf.length(${emit(object)})`;
     }
-    return this.renderNode(node);
+    return `${emit(object)}.${property}`;
   }
-  addCondMarkerToFirstElement(content, condId) {
-    const match = content.match(/^(<\w+)([\s>])/);
-    if (match) {
-      return content.replace(/^(<\w+)([\s>])/, `$1 ${BF_COND}="${condId}"$2`);
+  indexAccess(object, index, emit) {
+    return `${emit(object)}[${emit(index)}]`;
+  }
+  call(callee, args, emit) {
+    if (callee.kind === "identifier" && args.length === 0) {
+      return `$${callee.name}`;
     }
-    return `<: $bf.comment("cond-start:${condId}") | mark_raw :>${content}<: $bf.comment("cond-end:${condId}") | mark_raw :>`;
+    return emit(callee);
   }
-  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);
-      }
+  unary(op, argument, emit) {
+    const arg = emit(argument);
+    if (op === "!") {
+      const needsParens = argument.kind === "binary" || argument.kind === "logical";
+      return needsParens ? `!(${arg})` : `!${arg}`;
     }
-    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;
-        }
-      }
+    if (op === "-")
+      return `-${arg}`;
+    return arg;
+  }
+  binary(op, left, right, emit) {
+    const l = emit(left);
+    const r = emit(right);
+    const opMap = {
+      "===": "==",
+      "!==": "!=",
+      ">": ">",
+      "<": "<",
+      ">=": ">=",
+      "<=": "<=",
+      "+": "+",
+      "-": "-",
+      "*": "*",
+      "/": "/"
     };
-    visit(ir.root, false);
+    return `${l} ${opMap[op] ?? op} ${r}`;
   }
-  renderLoop(loop) {
-    if (loop.clientOnly)
-      return "";
-    const destructure = !!(loop.paramBindings && loop.paramBindings.length > 0);
-    const supportableDestructure = destructure && isLowerableObjectRestDestructure(loop);
-    if (destructure && !supportableDestructure) {
-      this.errors.push({
-        code: "BF104",
-        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" : supportableDestructure ? "__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;`);
-    }
-    if (supportableDestructure) {
-      for (const b of loop.paramBindings ?? []) {
-        indexLocalLines.push(b.rest ? `: my $${b.name} = $${loopVar};` : `: my $${b.name} = $${loopVar}${b.path};`);
-      }
-    }
-    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(`
-`);
+  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})`;
   }
-  componentPropEmitter = {
-    emitLiteral: (value, name) => `${kolonHashKey(name)} => '${value.value}'`,
-    emitExpression: (value, name) => {
-      if (value.parts) {
-        return `${kolonHashKey(name)} => ${this.convertTemplateLiteralPartsToKolon(value.parts)}`;
-      }
-      return `${kolonHashKey(name)} => ${this.convertExpressionToKolon(value.expr)}`;
-    },
-    emitSpread: (value) => {
-      return this.convertExpressionToKolon(value.expr);
-    },
-    emitTemplate: (value, name) => `${kolonHashKey(name)} => ${this.convertTemplateLiteralPartsToKolon(value.parts)}`,
-    emitBooleanAttr: (_value, name) => `${kolonHashKey(name)} => 1`,
-    emitBooleanShorthand: (_value, name) => `${kolonHashKey(name)} => 1`,
-    emitJsxChildren: () => ""
-  };
-  renderComponent(comp) {
-    const propParts = [];
-    for (const p of comp.props) {
-      if ((p.name.match(/^on[A-Z]/) || p.name === "ref") && p.value.kind === "expression")
-        continue;
-      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}'`);
+  callbackMethod(method, object, _arrow, _restArgs, emit) {
+    return emit(object);
+  }
+  arrayLiteral(elements, emit) {
+    return `[${elements.map(emit).join(", ")}]`;
+  }
+  arrayMethod(method, object, args, emit) {
+    return renderArrayMethod(method, object, args, emit);
+  }
+  flatMethod(object, depth, emit) {
+    return renderFlatMethod(emit(object), depth);
+  }
+  conditional(_test, _consequent, _alternate) {
+    return "1";
+  }
+  templateLiteral(_parts) {
+    return "1";
+  }
+  arrow(_params, _body) {
+    return "1";
+  }
+  regex(_raw) {
+    return "1";
+  }
+  unsupported(_raw, _reason) {
+    return "1";
+  }
+  objectLiteral(_properties, _raw, _emit) {
+    return "1";
+  }
+}
+
+class XslateTopLevelEmitter {
+  ctx;
+  constructor(ctx) {
+    this.ctx = ctx;
+  }
+  identifier(name) {
+    if (name === "undefined" || name === "null")
+      return "nil";
+    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 "nil";
+    return String(value);
+  }
+  member(object, property, _computed, emit) {
+    if (object.kind === "identifier" && object.name === "props") {
+      return `$${property}`;
     }
-    const tplName = this.toTemplateName(comp.name);
-    const effectiveChildren = comp.children.length > 0 ? comp.children : resolveJsxChildrenProp(comp.props);
-    if (effectiveChildren.length > 0) {
-      const prevInLoop = this.inLoop;
-      this.inLoop = false;
-      const childrenBody = this.renderChildren(effectiveChildren);
-      this.inLoop = prevInLoop;
-      const 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 :>`;
+    if (object.kind === "identifier") {
+      const staticValue = this.ctx._resolveStaticRecordLiteral(object.name, property);
+      if (staticValue !== null)
+        return staticValue;
     }
-    const hashEntries = propParts.length > 0 ? `, { ${propParts.join(", ")} }` : "";
-    return `<: $bf.render_child('${tplName}'${hashEntries}) | mark_raw :>`;
+    const obj = emit(object);
+    if (property === "length")
+      return `$bf.length(${obj})`;
+    return `${obj}.${property}`;
   }
-  childrenCaptureCounter = 0;
-  presenceVarCounter = 0;
-  toTemplateName(componentName) {
-    return componentName.replace(/([A-Z])/g, "_$1").toLowerCase().replace(/^_/, "");
+  indexAccess(object, index, emit) {
+    return `${emit(object)}[${emit(index)}]`;
   }
-  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}
-`;
+  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(", ")})`;
       }
     }
-    result += `: }`;
-    return result;
+    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.ctx._recordExprBF101(`templatePrimitive '${path}' expects ${spec.arity} arg(s), got ${args.length}`, `Call '${path}' with exactly ${spec.arity} argument(s).`);
+      return "''";
+    }
+    return emit(callee);
   }
-  renderFragment(fragment) {
-    const children = this.renderChildren(fragment.children);
-    if (fragment.needsScopeComment) {
-      return `<: $bf.scope_comment() | mark_raw :>${children}`;
+  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 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 (PREDICATE_METHODS.has(method)) {
+      return this._emitPredicateCallback({ method, object, param: params[0], predicate: body }, recv, emit);
+    }
+    if (method === "sort" || method === "toSorted") {
+      const evalForm = renderSortEval(recv, body, params, emit);
+      if (evalForm !== null)
+        return evalForm;
+      const structured = sortComparatorFromArrow(arrow);
+      if (structured !== null)
+        return renderSortMethod(recv, structured);
+      this.ctx._recordExprBF101(`'.${method}(...)' comparator is outside the Xslate adapter's evaluable / structured surface`, `Pre-compute the sorted array, or move this position to a '/* @client */' boundary.`);
+      return "''";
     }
-    return children;
+    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 outside the Xslate adapter's evaluable surface (needs a literal initial value and an evaluable reducer body)`, `Pre-compute the reduced value, or move this position to a '/* @client */' boundary.`);
+      return "''";
+    }
+    if (method === "flatMap") {
+      const evalForm = renderFlatMapEval(recv, body, params[0], emit);
+      if (evalForm !== null)
+        return evalForm;
+      this.ctx._recordExprBF101(`'.flatMap(...)' projection is outside the Xslate adapter's evaluable surface`, `Pre-compute the projected array, or move this position to a '/* @client */' boundary.`);
+      return "''";
+    }
+    return recv;
   }
-  renderSlot(_slot) {
-    return `<: $children | mark_raw :>`;
+  _emitPredicateCallback(call, arrayExpr, emit) {
+    const { method, object, param, predicate } = call;
+    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._renderKolonFilterExprPublic(predicate, param);
+    const lambda = `-> $${param} { ${predBody} }`;
+    const fn = {
+      filter: "filter",
+      every: "every",
+      some: "some",
+      find: "find",
+      findIndex: "find_index",
+      findLast: "find_last",
+      findLastIndex: "find_last_index"
+    };
+    if (fn[method])
+      return `$bf.${fn[method]}(${arrayExpr}, ${lambda})`;
+    return emit(object);
   }
-  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}`;
+  arrayLiteral(elements, emit) {
+    return `[${elements.map(emit).join(", ")}]`;
   }
-  elementAttrEmitter = {
-    emitLiteral: (value, name) => `${name}="${value.value}"`,
-    emitExpression: (value, name) => {
-      if (name === "style") {
-        const css = this.tryLowerStyleObject(value.expr);
-        if (css !== null)
-          return `style="${css}"`;
-      }
-      if (this.refuseUnsupportedAttrExpression(value.expr, name)) {
-        return "";
-      }
-      const bareId = value.expr.trim();
-      const normalizedBareId = this.propsObjectName && bareId.startsWith(`${this.propsObjectName}.`) ? bareId.slice(this.propsObjectName.length + 1) : bareId;
-      if (!isBooleanAttr(name) && !value.presenceOrUndefined && /^[A-Za-z_$][\w$]*$/.test(normalizedBareId) && this.nullableOptionalProps.has(normalizedBareId)) {
-        const perl2 = this.convertExpressionToKolon(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.convertExpressionToKolon(value.expr)} ? '${name}' : '' :>`;
-      }
-      if (value.presenceOrUndefined) {
-        const perl2 = this.convertExpressionToKolon(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.convertExpressionToKolon(m.condition);
-          const val = this.convertExpressionToKolon(m.consequent);
-          return `
-: if (${cond}) {
-${name}="<: ${val} :>"
-: }
-`;
-        }
-      }
-      const perl = this.convertExpressionToKolon(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.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 ternaryHashref = this.conditionalSpreadToKolon(trimmed);
-      if (ternaryHashref !== null) {
-        return `<: $bf.spread_attrs(${ternaryHashref}) | mark_raw :>`;
-      }
-      if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) {
-        const localConst = (this.localConstants ?? []).find((c) => c.name === trimmed && !c.isModule);
-        if (localConst?.value !== undefined) {
-          const initTrimmed = localConst.value.trim();
-          if (!/^[A-Za-z_$][\w$]*$/.test(initTrimmed)) {
-            const resolved = this.conditionalSpreadToKolon(initTrimmed);
-            if (resolved !== null) {
-              return `<: $bf.spread_attrs(${resolved}) | mark_raw :>`;
-            }
-          }
-        }
-      }
-      const perlExpr = this.convertExpressionToKolon(value.expr);
-      return `<: $bf.spread_attrs(${perlExpr}) | mark_raw :>`;
-    },
-    emitBooleanShorthand: () => "",
-    emitJsxChildren: () => ""
-  };
-  tryLowerStyleObject(expr) {
-    const entries = parseStyleObjectEntries(expr);
-    if (!entries)
-      return null;
-    for (const e of entries) {
-      if (e.kind === "expr" && !isSupported(parseExpression2(e.expr)).supported)
-        return null;
-    }
-    return entries.map((e) => e.kind === "literal" ? `${this.escapeAttrText(e.cssKey)}:${this.escapeAttrText(e.value)}` : `${this.escapeAttrText(e.cssKey)}:<: ${this.convertExpressionToKolon(e.expr)} :>`).join(";");
+  arrayMethod(method, object, args, emit) {
+    return renderArrayMethod(method, object, args, emit);
   }
-  escapeAttrText(s) {
-    return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  flatMethod(object, depth, emit) {
+    return renderFlatMethod(emit(object), depth);
   }
-  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);
+  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);
+      }
     }
-    return parts.length > 0 ? " " + parts.join(" ") : "";
+    if (terms.length === 0)
+      return `''`;
+    return terms.join(" ~ ");
   }
-  renderScopeMarker(_instanceIdExpr) {
-    return `bf-s="<: $bf.scope_attr() :>" <: $bf.hydration_attrs() | mark_raw :> <: $bf.props_attr() | mark_raw :>`;
+  arrow(_params, _body) {
+    return "''";
   }
-  renderSlotMarker(slotId) {
-    return `${BF_SLOT}="${slotId}"`;
+  regex(_raw) {
+    return "''";
   }
-  renderCondMarker(condId) {
-    return `${BF_COND}="${condId}"`;
+  unsupported(_raw, _reason) {
+    return "''";
   }
-  renderKolonFilterExpr(expr, param, localVarMap = new Map) {
-    return emitParsedExpr(expr, new XslateFilterEmitter(param, localVarMap, (n) => this._isStringValueName(n)));
+  objectLiteral(_properties, _raw, _emit) {
+    return "''";
   }
-  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(" || ")})`;
+}
+
+// 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);
+    }
   }
-  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 });
+  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 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;
       }
-    }
-    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);
+      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;
       }
-      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}] // '')`);
+      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;
       }
-    }
-    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)}'`);
+      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;
       }
-      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;
+  };
+  visit(ir.root, false);
+  return errors;
+}
+
+// src/adapter/spread/spread-codegen.ts
+var import_typescript = __toESM(require_typescript(), 1);
+import { parseRecordIndexAccess, stringifyParsedExpr } from "@barefootjs/jsx";
+function conditionalSpreadToKolon(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;
   }
-  conditionalSpreadToKolon(expr) {
-    const sf = import_typescript.default.createSourceFile("__spread.ts", `(${expr})`, import_typescript.default.ScriptTarget.Latest, true);
-    if (sf.statements.length !== 1)
-      return null;
-    const stmt = sf.statements[0];
-    if (!import_typescript.default.isExpressionStatement(stmt))
+  const condKolon = ctx.convertExpressionToKolon("", expr.test);
+  const trueKolon = objectLiteralToKolonHashref(ctx, whenTrue);
+  const falseKolon = objectLiteralToKolonHashref(ctx, whenFalse);
+  if (trueKolon === null || falseKolon === null)
+    return null;
+  return `${condKolon} ? ${trueKolon} : ${falseKolon}`;
+}
+function objectLiteralExprToKolonHashref(ctx, expr) {
+  if (!expr || expr.kind !== "object-literal")
+    return null;
+  return objectLiteralToKolonHashref(ctx, expr);
+}
+function objectLiteralToKolonHashref(ctx, obj) {
+  const entries = [];
+  for (const prop of obj.properties) {
+    if (prop.shorthand)
       return null;
-    let node = stmt.expression;
-    while (import_typescript.default.isParenthesizedExpression(node))
-      node = node.expression;
-    if (!import_typescript.default.isConditionalExpression(node))
+    if (prop.keyKind === "numeric")
       return null;
-    const unwrap = (e) => {
-      let n = e;
-      while (import_typescript.default.isParenthesizedExpression(n))
-        n = n.expression;
-      return n;
-    };
-    const whenTrue = unwrap(node.whenTrue);
-    const whenFalse = unwrap(node.whenFalse);
-    if (!import_typescript.default.isObjectLiteralExpression(whenTrue) || !import_typescript.default.isObjectLiteralExpression(whenFalse)) {
+    const key = prop.key;
+    const val = prop.value;
+    const indexed = recordIndexAccessToKolon(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 Kolon 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 condPerl = this.convertExpressionToKolon(node.condition.getText(sf));
-    const truePerl = this.objectLiteralToKolonHashref(whenTrue, sf);
-    const falsePerl = this.objectLiteralToKolonHashref(whenFalse, sf);
-    if (truePerl === null || falsePerl === null)
-      return null;
-    return `${condPerl} ? ${truePerl} : ${falsePerl}`;
-  }
-  objectLiteralToKolonHashref(obj, sf) {
-    const entries = [];
-    for (const prop of obj.properties) {
-      if (!import_typescript.default.isPropertyAssignment(prop))
-        return null;
-      let key;
-      if (import_typescript.default.isIdentifier(prop.name)) {
-        key = prop.name.text;
-      } else if (import_typescript.default.isStringLiteral(prop.name) || import_typescript.default.isNoSubstitutionTemplateLiteral(prop.name)) {
-        key = prop.name.text;
-      } else {
-        return null;
-      }
-      const initNode = (() => {
-        let n = prop.initializer;
-        while (import_typescript.default.isParenthesizedExpression(n))
-          n = n.expression;
-        return n;
-      })();
-      const indexed = this.recordIndexAccessToKolon(initNode);
-      if (indexed === null && import_typescript.default.isElementAccessExpression(initNode) && initNode.argumentExpression && !import_typescript.default.isNumericLiteral(initNode.argumentExpression) && !import_typescript.default.isStringLiteral(initNode.argumentExpression)) {
-        this.errors.push({
-          code: "BF101",
-          severity: "error",
-          message: `Spread object value '${initNode.getText(sf)}' indexes a record map whose values aren't scalar literals — it can't lower to an inline Kolon hashref.`,
-          loc: { file: this.componentName + ".tsx", start: { line: 1, column: 0 }, end: { line: 1, column: 0 } },
-          suggestion: {
-            message: "Index a record whose values are number/string literals, or move the spread into a `'use client'` component so hydration computes it."
-          }
-        });
-        return null;
-      }
-      const valPerl = indexed !== null ? indexed : this.convertExpressionToKolon(prop.initializer.getText(sf));
-      entries.push(`'${escapeKolonSingleQuoted(key)}' => ${valPerl}`);
-    }
-    return entries.length === 0 ? "{}" : `{ ${entries.join(", ")} }`;
-  }
-  recordIndexAccessToKolon(val) {
-    const parsed = parseRecordIndexAccess(val, this.localConstants ?? [], this.propsParams);
-    if (!parsed)
-      return null;
-    const entries = parsed.entries.map((e) => {
-      const mapVal = e.value.kind === "number" ? e.value.text : `'${escapeKolonSingleQuoted(e.value.text)}'`;
-      return `'${escapeKolonSingleQuoted(e.key)}' => ${mapVal}`;
-    });
-    return `{ ${entries.join(", ")} }[$${parsed.indexPropName}]`;
-  }
-  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);
-  }
-  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)
-    };
-  }
-  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;
-    return this.booleanTypedProps.has(bare);
-  }
-  _resolveLiteralConst(name) {
-    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) {
-    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.inLoop)
-      return null;
-    const value = this.moduleStringConsts.get(name);
-    if (value === undefined)
-      return null;
-    return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
-  }
-  _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);
+    const valKolon = indexed !== null ? indexed : ctx.convertExpressionToKolon("", val);
+    entries.push(`'${escapeKolonSingleQuoted(key)}' => ${valKolon}`);
   }
+  return entries.length === 0 ? "{}" : `{ ${entries.join(", ")} }`;
 }
-function renderArrayMethod(method, object, args, emit) {
-  switch (method) {
-    case "join": {
-      const obj = emit(object);
-      const sep2 = args.length >= 1 ? emit(args[0]) : `','`;
-      return `$bf.join(${obj}, ${sep2})`;
-    }
-    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]) : "nil";
-      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 "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 sep2 = emit(args[0]);
-      if (args.length === 1) {
-        return `$bf.split(${recv}, ${sep2})`;
-      }
-      const limit = emit(args[1]);
-      return `$bf.split(${recv}, ${sep2}, ${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 pad2 = emit(args[1]);
-      return `$bf.${fn}(${recv}, ${target}, ${pad2})`;
-    }
-    default: {
-      const _exhaustive = method;
-      throw new Error(`renderArrayMethod: unhandled ArrayMethod '${_exhaustive}'`);
-    }
-  }
+function isLiteralIndex(index) {
+  return index.kind === "literal" && (index.literalType === "number" || index.literalType === "string");
 }
-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}' }`;
+function recordIndexAccessToKolon(ctx, val) {
+  if (val.kind !== "index-access" || val.object.kind !== "identifier" || val.index.kind !== "identifier") {
+    return null;
+  }
+  const tsVal = import_typescript.default.factory.createElementAccessExpression(import_typescript.default.factory.createIdentifier(val.object.name), import_typescript.default.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 : `'${escapeKolonSingleQuoted(e.value.text)}'`;
+    return `'${escapeKolonSingleQuoted(e.key)}' => ${mapVal}`;
   });
-  return `$bf.sort(${recv}, { keys => [${keyHashes.join(", ")}] })`;
+  return `{ ${entries.join(", ")} }[$${parsed.indexPropName}]`;
 }
-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}' })`;
+
+// src/adapter/memo/seed.ts
+import {
+  collectContextConsumers,
+  extractArrowBodyExpression,
+  isSupported,
+  parseExpression as parseExpression2
+} from "@barefootjs/jsx";
+function contextDefaultKolon(c) {
+  const d = c.defaultValue;
+  if (d === null || d === undefined)
+    return "nil";
+  if (typeof d === "string")
+    return `'${d.replace(/[\\']/g, (m) => `\\${m}`)}'`;
+  if (typeof d === "boolean")
+    return d ? "1" : "0";
+  return String(d);
 }
-function renderFlatMethod(recv, depth) {
-  const d = depth === "infinity" ? -1 : depth;
-  return `$bf.flat(${recv}, ${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}', ${contextDefaultKolon(c)});`).join(`
+`) + `
+`;
 }
-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})`;
+function generateDerivedMemoSeed(ctx, ir) {
+  const memos = ir.metadata.memos ?? [];
+  const signals = ir.metadata.signals ?? [];
+  if (memos.length === 0 && signals.length === 0)
+    return "";
+  const available = new Set(ir.metadata.propsParams.map((p) => p.name));
+  const lines = [];
+  for (const signal of signals) {
+    const kolon = tryLowerToKolon(ctx, signal.initialValue, available);
+    const refsSelf = kolon !== null && new RegExp(`\\$${signal.getter}\\b`).test(kolon);
+    if (kolon !== null && !refsSelf)
+      lines.push(`: my $${signal.getter} = ${kolon};`);
+    available.add(signal.getter);
   }
-  if (proj.kind === "self")
-    return `$bf.flat_map(${recv}, 'self', '')`;
-  return `$bf.flat_map(${recv}, 'field', '${proj.field}')`;
+  for (const memo of memos) {
+    const body = extractArrowBodyExpression(memo.computation);
+    if (body !== null) {
+      const kolon = tryLowerToKolon(ctx, body, available);
+      const refsSelf = kolon !== null && new RegExp(`\\$${memo.name}\\b`).test(kolon);
+      if (kolon !== null && !refsSelf)
+        lines.push(`: my $${memo.name} = ${kolon};`);
+    }
+    available.add(memo.name);
+  }
+  return lines.length > 0 ? lines.join(`
+`) + `
+` : "";
+}
+function tryLowerToKolon(ctx, expr, available) {
+  const trimmed = expr.trim();
+  if (!trimmed)
+    return null;
+  if (!isSupported(parseExpression2(trimmed)).supported)
+    return null;
+  const kolon = ctx.convertExpressionToKolon(trimmed);
+  if (kolon === "" || !/\$[A-Za-z_]\w*/.test(kolon))
+    return null;
+  return referencedVarsAreAvailable(kolon, available) ? kolon : null;
 }
+
+// src/adapter/value/parsed-literal.ts
+import { evalStringArrayJoin } from "@barefootjs/jsx";
 function isStringTypeInfo(type2) {
   return type2?.kind === "primitive" && type2.primitive === "string";
 }
@@ -188589,274 +188165,802 @@ function isBareStringLiteral(initialValue) {
   const v = initialValue.trim();
   return v.startsWith("'") && v.endsWith("'") || v.startsWith('"') && v.endsWith('"');
 }
-class XslateFilterEmitter {
-  param;
-  localVarMap;
-  isStringName;
-  constructor(param, localVarMap, isStringName = () => false) {
-    this.param = param;
-    this.localVarMap = localVarMap;
-    this.isStringName = isStringName;
+
+// src/adapter/props/prop-classes.ts
+function collectBooleanTypedProps(ir) {
+  return new Set(ir.metadata.propsParams.filter((prop) => prop.type?.primitive === "boolean" || prop.type?.raw === "boolean").map((prop) => prop.name));
+}
+function collectNullableOptionalProps(ir) {
+  return new Set(ir.metadata.propsParams.filter((p) => p.defaultValue === undefined && !p.isRest && p.type?.kind !== "primitive").map((p) => p.name));
+}
+function collectStringValueNames(ir) {
+  const names = new Set;
+  for (const s of ir.metadata.signals) {
+    if (isStringTypeInfo(s.type) || isBareStringLiteral(s.initialValue)) {
+      names.add(s.getter);
+    }
   }
-  identifier(name) {
-    if (name === this.param)
-      return `$${this.param}`;
-    const signal = this.localVarMap.get(name);
-    if (signal)
-      return `$${signal}`;
-    return `$${name}`;
+  for (const p of ir.metadata.propsParams) {
+    if (isStringTypeInfo(p.type))
+      names.add(p.name);
   }
-  literal(value, literalType) {
-    if (literalType === "string")
-      return `'${value}'`;
-    if (literalType === "boolean")
-      return value ? "1" : "0";
-    if (literalType === "null")
-      return "nil";
-    return String(value);
+  return names;
+}
+
+// src/adapter/xslate-adapter.ts
+class XslateAdapter extends BaseAdapter {
+  name = "xslate";
+  extension = ".tx";
+  templatesPerComponent = true;
+  importMapInjection = "html-snippet";
+  templatePrimitives = XSLATE_PRIMITIVE_EMIT_MAP;
+  componentName = "";
+  rootScopeNodes = new Set;
+  options;
+  errors = [];
+  inLoop = false;
+  propsObjectName = null;
+  propsParams = [];
+  booleanTypedProps = new Set;
+  stringValueNames = new Set;
+  moduleStringConsts = new Map;
+  _searchParamsLocals = new Set;
+  _loweringMatchers = [];
+  localConstants = [];
+  nullableOptionalProps = new Set;
+  constructor(options = {}) {
+    super();
+    this.options = {
+      clientJsBasePath: options.clientJsBasePath ?? "/static/components/",
+      barefootJsPath: options.barefootJsPath ?? "/static/components/barefoot.js"
+    };
   }
-  member(object, property, _computed, emit) {
-    if (property === "length") {
-      return `$bf.length(${emit(object)})`;
+  generate(ir, options) {
+    this.componentName = ir.metadata.componentName;
+    this.propsObjectName = ir.metadata.propsObjectName ?? null;
+    augmentInheritedPropAccesses(ir);
+    this.propsParams = ir.metadata.propsParams.map((p) => ({ name: p.name }));
+    this.booleanTypedProps = collectBooleanTypedProps(ir);
+    this.localConstants = ir.metadata.localConstants ?? [];
+    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.errors = [];
+    this.childrenCaptureCounter = 0;
+    if (!options?.siblingTemplatesRegistered) {
+      this.errors.push(...collectImportedLoopChildComponentErrors(ir, this.componentName));
     }
-    return `${emit(object)}.${property}`;
+    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
+    };
   }
-  indexAccess(object, index, emit) {
-    return `${emit(object)}[${emit(index)}]`;
+  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(`: my $_bf_reg0 = $bf.register_script('${runtimePath}');`);
+    lines.push(`: my $_bf_reg1 = $bf.register_script('${clientJsPath}');`);
+    lines.push("");
+    return lines.join(`
+`);
   }
-  call(callee, args, emit) {
-    if (callee.kind === "identifier" && args.length === 0) {
-      return `$${callee.name}`;
-    }
-    return emit(callee);
+  renderNode(node) {
+    return emitIRNode(node, this, {});
   }
-  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;
+  emitElement(node, _ctx, _emit) {
+    return this.renderElement(node);
   }
-  binary(op, left, right, emit) {
-    const l = emit(left);
-    const r = emit(right);
-    const opMap = {
-      "===": "==",
-      "!==": "!=",
-      ">": ">",
-      "<": "<",
-      ">=": ">=",
-      "<=": "<=",
-      "+": "+",
-      "-": "-",
-      "*": "*",
-      "/": "/"
-    };
-    return `${l} ${opMap[op] ?? op} ${r}`;
+  emitText(node) {
+    return node.value;
   }
-  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})`;
+  emitExpression(node) {
+    return this.renderExpression(node);
   }
-  higherOrder(method, object, param, predicate, emit) {
-    return emit(object);
+  emitConditional(node, _ctx, _emit) {
+    return this.renderConditional(node);
   }
-  arrayLiteral(elements, emit) {
-    return `[${elements.map(emit).join(", ")}]`;
+  emitLoop(node, _ctx, _emit) {
+    return this.renderLoop(node);
   }
-  arrayMethod(method, object, args, emit) {
-    return renderArrayMethod(method, object, args, emit);
+  emitComponent(node, _ctx, _emit) {
+    return this.renderComponent(node);
   }
-  sortMethod(_method, object, comparator, emit) {
-    return renderSortMethod(emit(object), comparator);
+  emitFragment(node, _ctx, _emit) {
+    return this.renderFragment(node);
   }
-  reduceMethod(method, object, reduceOp, emit) {
-    return renderReduceMethod(emit(object), reduceOp, method === "reduceRight" ? "right" : "left");
+  emitSlot(node) {
+    return this.renderSlot(node);
   }
-  flatMethod(object, depth, emit) {
-    return renderFlatMethod(emit(object), depth);
+  emitIfStatement(node, _ctx, _emit) {
+    return this.renderIfStatement(node);
   }
-  flatMapMethod(object, op, emit) {
-    return renderFlatMapMethod(emit(object), op);
+  emitProvider(node, _ctx, _emit) {
+    const value = this.providerValueKolon(node.valueProp);
+    const children = this.renderChildren(node.children);
+    const name = node.contextName;
+    return `<: $bf.provide_context('${name}', ${value}) :>` + children + `<: $bf.revoke_context('${name}') :>`;
   }
-  conditional(_test, _consequent, _alternate) {
-    return "1";
+  providerValueKolon(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.providerObjectLiteralKolon(v.expr);
+      if (hashref !== null)
+        return hashref;
+      return this.convertExpressionToKolon(v.expr);
+    }
+    if (v.kind === "template")
+      return this.convertTemplateLiteralPartsToKolon(v.parts);
+    return "nil";
   }
-  templateLiteral(_parts) {
-    return "1";
+  providerObjectLiteralKolon(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} => nil`;
+      const src = m.kind === "getter" ? m.body : m.expr;
+      return `${key} => ${this.convertExpressionToKolon(src)}`;
+    });
+    return `{ ${entries.join(", ")} }`;
   }
-  arrowFn(_param, _body) {
-    return "1";
+  emitAsync(node, _ctx, _emit) {
+    return this.renderAsync(node);
   }
-  unsupported(_raw, _reason) {
-    return "1";
+  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 (this.rootScopeNodes.has(element) && element.needsScope) {
+      hydrationAttrs += ` <: $bf.data_key_attr() | mark_raw :>`;
+    }
+    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}>`;
   }
-}
-
-class XslateTopLevelEmitter {
-  adapter;
-  constructor(adapter) {
-    this.adapter = adapter;
+  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} :>`;
   }
-  identifier(name) {
-    if (name === "undefined" || name === "null")
-      return "nil";
-    const inlined = this.adapter._resolveModuleStringConst(name);
-    if (inlined !== null)
-      return inlined;
-    const literalConst = this.adapter._resolveLiteralConst(name);
-    if (literalConst !== null)
-      return literalConst;
-    return `$${name}`;
+  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 :>`;
+  }
+  renderLoop(loop) {
+    if (loop.clientOnly)
+      return "";
+    const destructure = !!(loop.paramBindings && loop.paramBindings.length > 0);
+    const supportableDestructure = destructure && isLowerableObjectRestDestructure(loop);
+    if (destructure && !supportableDestructure) {
+      this.errors.push({
+        code: "BF104",
+        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) {
+      const sort = loop.sortComparator;
+      const sortEmit = (e) => this.convertExpressionToKolon("", e);
+      const arrow = sort.arrow;
+      const params = arrow.kind === "arrow" ? arrow.params : [sort.paramA, sort.paramB];
+      const structured = sortComparatorFromArrow2(arrow);
+      array = renderSortEval(rawArray, arrow.kind === "arrow" ? arrow.body : arrow, params, sortEmit) ?? (structured !== null ? renderSortMethod(rawArray, structured) : rawArray);
+    }
+    const param = loop.param;
+    const renderedChildren = this.renderChildren(loop.children);
+    const loopVar = loop.iterationShape === "keys" ? "__bf_item" : supportableDestructure ? "__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;`);
+    }
+    if (supportableDestructure) {
+      for (const b of loop.paramBindings ?? []) {
+        indexLocalLines.push(b.rest ? `: my $${b.name} = $${loopVar};` : `: my $${b.name} = $${loopVar}${b.path};`);
+      }
+    }
+    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.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) => `${kolonHashKey(name)} => '${value.value}'`,
+    emitExpression: (value, name) => {
+      if (value.parts) {
+        return `${kolonHashKey(name)} => ${this.convertTemplateLiteralPartsToKolon(value.parts)}`;
+      }
+      if (value.parsed) {
+        const hashref = objectLiteralExprToKolonHashref(this.spreadCtx, value.parsed);
+        if (hashref !== null)
+          return `${kolonHashKey(name)} => ${hashref}`;
+      }
+      return `${kolonHashKey(name)} => ${this.convertExpressionToKolon(value.expr)}`;
+    },
+    emitSpread: (value) => {
+      return this.convertExpressionToKolon(value.expr);
+    },
+    emitTemplate: (value, name) => `${kolonHashKey(name)} => ${this.convertTemplateLiteralPartsToKolon(value.parts)}`,
+    emitBooleanAttr: (_value, name) => `${kolonHashKey(name)} => 1`,
+    emitBooleanShorthand: (_value, name) => `${kolonHashKey(name)} => 1`,
+    emitJsxChildren: () => ""
+  };
+  renderComponent(comp) {
+    const propParts = [];
+    for (const p of comp.props) {
+      if ((p.name.match(/^on[A-Z]/) || p.name === "ref") && p.value.kind === "expression")
+        continue;
+      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 prevInLoop = this.inLoop;
+      this.inLoop = false;
+      const childrenBody = this.renderChildren(effectiveChildren);
+      this.inLoop = prevInLoop;
+      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;
+  presenceVarCounter = 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 (name === "style") {
+        const css = this.tryLowerStyleObject(value.expr);
+        if (css !== null)
+          return `style="${css}"`;
+      }
+      if (this.refuseUnsupportedAttrExpression(value.expr, name)) {
+        return "";
+      }
+      const bareId = value.expr.trim();
+      const normalizedBareId = this.propsObjectName && bareId.startsWith(`${this.propsObjectName}.`) ? bareId.slice(this.propsObjectName.length + 1) : bareId;
+      if (!isBooleanAttr(name) && !value.presenceOrUndefined && /^[A-Za-z_$][\w$]*$/.test(normalizedBareId) && this.nullableOptionalProps.has(normalizedBareId)) {
+        const perl2 = this.convertExpressionToKolon(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.convertExpressionToKolon(value.expr)} ? '${name}' : '' :>`;
+      }
+      if (value.presenceOrUndefined) {
+        const perl2 = this.convertExpressionToKolon(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.convertExpressionToKolon(m.condition);
+          const val = this.convertExpressionToKolon(m.consequent);
+          return `
+: if (${cond}) {
+${name}="<: ${val} :>"
+: }
+`;
+        }
+      }
+      const perl = this.convertExpressionToKolon(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.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 ternaryHashref = conditionalSpreadToKolon(this.spreadCtx, value.parsed);
+      if (ternaryHashref !== null) {
+        return `<: $bf.spread_attrs(${ternaryHashref}) | mark_raw :>`;
+      }
+      if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) {
+        const localConst = (this.localConstants ?? []).find((c) => c.name === trimmed && !c.isModule);
+        if (localConst?.value !== undefined) {
+          const initTrimmed = localConst.value.trim();
+          if (!/^[A-Za-z_$][\w$]*$/.test(initTrimmed)) {
+            const resolved = conditionalSpreadToKolon(this.spreadCtx, parseExpression3(initTrimmed));
+            if (resolved !== null) {
+              return `<: $bf.spread_attrs(${resolved}) | mark_raw :>`;
+            }
+          }
+        }
+      }
+      const perlExpr = this.convertExpressionToKolon(value.expr);
+      return `<: $bf.spread_attrs(${perlExpr}) | mark_raw :>`;
+    },
+    emitBooleanShorthand: () => "",
+    emitJsxChildren: () => ""
+  };
+  tryLowerStyleObject(expr) {
+    const entries = parseStyleObjectEntries(expr);
+    if (!entries)
+      return null;
+    for (const e of entries) {
+      if (e.kind === "expr" && !isSupported2(parseExpression3(e.expr)).supported)
+        return null;
+    }
+    return entries.map((e) => e.kind === "literal" ? `${this.escapeAttrText(e.cssKey)}:${this.escapeAttrText(e.value)}` : `${this.escapeAttrText(e.cssKey)}:<: ${this.convertExpressionToKolon(e.expr)} :>`).join(";");
+  }
+  escapeAttrText(s) {
+    return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+  renderAttributes(element) {
+    const parts = [];
+    for (const attr of element.attrs) {
+      if (attr.clientOnly)
+        continue;
+      let attrName;
+      if (attr.name === "className")
+        attrName = "class";
+      else if (attr.name === "key")
+        attrName = "data-key";
+      else
+        attrName = attr.name;
+      const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, attrName);
+      if (lowered)
+        parts.push(lowered);
+    }
+    return parts.length > 0 ? " " + parts.join(" ") : "";
   }
-  literal(value, literalType) {
-    if (literalType === "string")
-      return `'${value}'`;
-    if (literalType === "boolean")
-      return value ? "1" : "0";
-    if (literalType === "null")
-      return "nil";
-    return String(value);
+  renderScopeMarker(_instanceIdExpr) {
+    return `bf-s="<: $bf.scope_attr() :>" <: $bf.hydration_attrs() | mark_raw :> <: $bf.props_attr() | mark_raw :>`;
   }
-  member(object, property, _computed, emit) {
-    if (object.kind === "identifier" && object.name === "props") {
-      return `$${property}`;
-    }
-    if (object.kind === "identifier") {
-      const staticValue = this.adapter._resolveStaticRecordLiteral(object.name, property);
-      if (staticValue !== null)
-        return staticValue;
-    }
-    const obj = emit(object);
-    if (property === "length")
-      return `$bf.length(${obj})`;
-    return `${obj}.${property}`;
+  renderSlotMarker(slotId) {
+    return `${BF_SLOT}="${slotId}"`;
   }
-  indexAccess(object, index, emit) {
-    return `${emit(object)}[${emit(index)}]`;
+  renderCondMarker(condId) {
+    return `${BF_COND}="${condId}"`;
   }
-  call(callee, args, emit) {
-    if (callee.kind === "identifier" && args.length === 0) {
-      return `$${callee.name}`;
-    }
-    if (this.adapter._searchParamsLocals.size > 0) {
-      const sp = matchSearchParamsMethodCall(callee, args, this.adapter._searchParamsLocals);
-      if (sp) {
-        return `$searchParams.${sp.method}(${sp.args.map(emit).join(", ")})`;
+  renderKolonFilterExpr(expr, param, localVarMap = new Map) {
+    return emitParsedExpr(expr, new XslateFilterEmitter(param, localVarMap, (n) => this._isStringValueName(n)));
+  }
+  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}] // '')`);
       }
     }
-    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));
+    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)}'`);
       }
-      this.adapter._recordExprBF101(`templatePrimitive '${path}' expects ${spec.arity} arg(s), got ${args.length}`, `Call '${path}' with exactly ${spec.arity} argument(s).`);
-      return "''";
+      segments.push(this.convertExpressionToKolon(m[1].trim()));
+      lastIndex = re.lastIndex;
     }
-    return emit(callee);
+    if (lastIndex < s.length) {
+      segments.push(`'${s.slice(lastIndex)}'`);
+    }
+    if (segments.length === 0)
+      return `''`;
+    return segments.length === 1 ? segments[0] : `(${segments.join(" ~ ")})`;
   }
-  unary(op, argument, emit) {
-    const arg = emit(argument);
-    if (op === "!")
-      return `!${arg}`;
-    if (op === "-")
-      return `-${arg}`;
-    return arg;
+  refuseUnsupportedAttrExpression(expr, attrName) {
+    let probe = expr.trim();
+    while (probe.startsWith("("))
+      probe = probe.slice(1).trimStart();
+    const startsAsObjectLiteral = probe.startsWith("{");
+    const hasTaggedTemplate = /[A-Za-z_$][\w$]*\s*`/.test(probe);
+    if (!startsAsObjectLiteral && !hasTaggedTemplate)
+      return false;
+    const parsed = parseExpression3(expr.trim());
+    const support = isSupported2(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;
   }
-  binary(op, left, right, emit) {
-    const l = emit(left);
-    const r = emit(right);
-    const opMap = {
-      "===": "==",
-      "!==": "!=",
-      ">": ">",
-      "<": "<",
-      ">=": ">=",
-      "<=": "<=",
-      "+": "+",
-      "-": "-",
-      "*": "*"
+  get emitCtx() {
+    return {
+      _searchParamsLocals: this._searchParamsLocals,
+      _resolveModuleStringConst: (name) => this._resolveModuleStringConst(name),
+      _resolveLiteralConst: (name) => this._resolveLiteralConst(name),
+      _resolveStaticRecordLiteral: (o, k) => this._resolveStaticRecordLiteral(o, k),
+      _recordExprBF101: (message, reason) => this._recordExprBF101(message, reason),
+      _renderKolonFilterExprPublic: (e, p) => this._renderKolonFilterExprPublic(e, p)
     };
-    return `${l} ${opMap[op] ?? op} ${r}`;
-  }
-  logical(op, left, right, emit) {
-    const l = emit(left);
-    const r = emit(right);
-    if (op === "&&")
-      return `(${l} && ${r})`;
-    if (op === "||")
-      return `(${l} || ${r})`;
-    return `(${l} // ${r})`;
   }
-  higherOrder(method, object, param, predicate, emit) {
-    const arrayExpr = emit(object);
-    const predBody = this.adapter._renderKolonFilterExprPublic(predicate, param);
-    const lambda = `-> $${param} { ${predBody} }`;
-    const fn = {
-      filter: "filter",
-      every: "every",
-      some: "some",
-      find: "find",
-      findIndex: "find_index",
-      findLast: "find_last",
-      findLastIndex: "find_last_index"
+  get spreadCtx() {
+    return {
+      componentName: this.componentName,
+      errors: this.errors,
+      localConstants: this.localConstants,
+      propsParams: this.propsParams,
+      convertExpressionToKolon: (e, preParsed) => this.convertExpressionToKolon(e, preParsed)
     };
-    if (fn[method])
-      return `$bf.${fn[method]}(${arrayExpr}, ${lambda})`;
-    return emit(object);
   }
-  arrayLiteral(elements, emit) {
-    return `[${elements.map(emit).join(", ")}]`;
+  get memoCtx() {
+    return { convertExpressionToKolon: (e, preParsed) => this.convertExpressionToKolon(e, preParsed) };
   }
-  arrayMethod(method, object, args, emit) {
-    return renderArrayMethod(method, object, args, emit);
+  convertExpressionToKolon(expr, preParsed) {
+    let parsed;
+    if (preParsed) {
+      parsed = preParsed;
+    } else {
+      const trimmed = expr.trim();
+      if (trimmed === "")
+        return "''";
+      parsed = parseExpression3(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 qArgs = queryHrefArgs(node, (n) => this.renderParsedExprToKolon(n));
+          return `$bf.query(${qArgs.join(", ")})`;
+        }
+      }
+    }
+    const support = isSupported2(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 the backend` : `Options:
+1. Use /* @client */ for client-side evaluation
+2. Pre-compute the value in the backend`
+        }
+      });
+      return "''";
+    }
+    return this.renderParsedExprToKolon(parsed);
   }
-  sortMethod(_method, object, comparator, emit) {
-    return renderSortMethod(emit(object), comparator);
+  renderParsedExprToKolon(expr) {
+    return emitParsedExpr(expr, new XslateTopLevelEmitter(this.emitCtx));
   }
-  reduceMethod(method, object, reduceOp, emit) {
-    return renderReduceMethod(emit(object), reduceOp, method === "reduceRight" ? "right" : "left");
+  _isStringValueName(name) {
+    return this.stringValueNames.has(name);
   }
-  flatMethod(object, depth, emit) {
-    return renderFlatMethod(emit(object), depth);
+  parseUndefinedAlternateTernary(expr) {
+    const parsed = parseExpression3(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)
+    };
+  }
+  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;
+    return this.booleanTypedProps.has(bare);
   }
-  flatMapMethod(object, op, emit) {
-    return renderFlatMapMethod(emit(object), op);
+  _resolveLiteralConst(name) {
+    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;
   }
-  conditional(test, consequent, alternate, emit) {
-    return `(${emit(test)} ? ${emit(consequent)} : ${emit(alternate)})`;
+  _resolveStaticRecordLiteral(objectName, key) {
+    const hit = lookupStaticRecordLiteral(objectName, key, this.localConstants);
+    if (!hit)
+      return null;
+    return hit.kind === "number" ? hit.text : `'${hit.text.replace(/[\\']/g, (m) => `\\${m}`)}'`;
   }
-  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(" ~ ");
+  _resolveModuleStringConst(name) {
+    if (this.inLoop)
+      return null;
+    const value = this.moduleStringConsts.get(name);
+    if (value === undefined)
+      return null;
+    return `'${value.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`;
   }
-  arrowFn(_param, _body) {
-    return "''";
+  _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`
+      }
+    });
   }
-  unsupported(_raw, _reason) {
-    return "''";
+  _renderKolonFilterExprPublic(expr, param) {
+    return this.renderKolonFilterExpr(expr, param);
   }
 }
 var xslateAdapter = new XslateAdapter;