@barefootjs/go-template 0.1.0

package/dist/adapter/index.js

@@ -0,0 +1,2672 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/adapter/go-template-adapter.ts
+import ts from "typescript";
+import {
+  BaseAdapter,
+  isBooleanAttr,
+  parseExpression,
+  isSupported,
+  exprToString,
+  identifierPath,
+  emitParsedExpr,
+  emitIRNode,
+  emitAttrValue
+} from "@barefootjs/jsx";
+import { findInterpolationEnd } from "@barefootjs/jsx/scanner";
+function wrapIfMultiToken(rendered) {
+  if (rendered.startsWith("(") && rendered.endsWith(")"))
+    return rendered;
+  if (rendered.startsWith('"') && rendered.endsWith('"'))
+    return rendered;
+  if (/\s/.test(rendered))
+    return `(${rendered})`;
+  return rendered;
+}
+function emitBfSort(recv, c) {
+  const keyKind = c.key.kind;
+  const keyName = c.key.kind === "field" ? capitalize(c.key.field) : "";
+  return `bf_sort ${wrapIfMultiToken(recv)} "${keyKind}" "${keyName}" "${c.type}" "${c.direction}"`;
+}
+function capitalize(s) {
+  return s.length === 0 ? s : s[0].toUpperCase() + s.slice(1);
+}
+function slotIdToFieldSuffix(slotId) {
+  const cleanId = slotId.startsWith("^") ? slotId.slice(1) : slotId;
+  const match = cleanId.match(/^s(\d+)$/);
+  if (match) {
+    return `Slot${match[1]}`;
+  }
+  return cleanId.replace("slot_", "Slot");
+}
+var GO_TEMPLATE_PRIMITIVES = {
+  "JSON.stringify": { arity: 1, emit: (args) => `bf_json ${args[0]}` },
+  String: { arity: 1, emit: (args) => `bf_string ${args[0]}` },
+  Number: { arity: 1, emit: (args) => `bf_number ${args[0]}` },
+  "Math.floor": { arity: 1, emit: (args) => `bf_floor ${args[0]}` },
+  "Math.ceil": { arity: 1, emit: (args) => `bf_ceil ${args[0]}` },
+  "Math.round": { arity: 1, emit: (args) => `bf_round ${args[0]}` }
+};
+
+class GoTemplateAdapter extends BaseAdapter {
+  name = "go-template";
+  extension = ".tmpl";
+  filterExprDepth = 0;
+  filterExprUnsupported = false;
+  templatePrimitives = Object.fromEntries(Object.entries(GO_TEMPLATE_PRIMITIVES).map(([k, v]) => [k, v.emit]));
+  templatePrimitiveArities = Object.fromEntries(Object.entries(GO_TEMPLATE_PRIMITIVES).map(([k, v]) => [k, v.arity]));
+  componentName = "";
+  options;
+  inLoop = false;
+  loopParamStack = [];
+  errors = [];
+  propsObjectName = null;
+  restPropsName = null;
+  localTypeNames = new Set;
+  localTypeAliases = new Map;
+  usesHtmlTemplate = false;
+  constructor(options = {}) {
+    super();
+    this.options = {
+      packageName: options.packageName ?? "components",
+      clientJsBasePath: options.clientJsBasePath ?? "/static/client/",
+      barefootJsPath: options.barefootJsPath ?? "/static/client/barefoot.js"
+    };
+  }
+  generate(ir, options) {
+    this.componentName = ir.metadata.componentName;
+    this.errors = [];
+    this.propsObjectName = ir.metadata.propsObjectName;
+    this.restPropsName = ir.metadata.restPropsName ?? null;
+    if (!options?.siblingTemplatesRegistered) {
+      this.checkImportedLoopChildComponents(ir);
+    }
+    const hasInteractivity = this.hasClientInteractivity(ir);
+    const isRootComponent = ir.root.type === "component";
+    const isIfStatement = ir.root.type === "if-statement";
+    const templateBody = isIfStatement ? this.renderIfStatement(ir.root, { isRootOfClientComponent: hasInteractivity }) : this.renderNode(ir.root, { isRootOfClientComponent: hasInteractivity && isRootComponent });
+    const scriptRegistrations = options?.skipScriptRegistration ? "" : this.generateScriptRegistrations(ir, options?.scriptBaseName);
+    const template = `{{define "${this.componentName}"}}
+${scriptRegistrations}${templateBody}
+{{end}}
+`;
+    const types = this.generateTypes(ir);
+    if (this.errors.length > 0) {
+      ir.errors.push(...this.errors);
+    }
+    const sections = {
+      imports: "",
+      types: "",
+      component: template,
+      defaultExport: ""
+    };
+    return {
+      template,
+      sections,
+      types: types || undefined,
+      extension: this.extension
+    };
+  }
+  hasClientInteractivity(ir) {
+    if (ir.metadata.signals.length > 0)
+      return true;
+    if (ir.metadata.effects.length > 0)
+      return true;
+    if (ir.metadata.onMounts.length > 0)
+      return true;
+    if (this.hasEventsInTree(ir.root))
+      return true;
+    if (this.findChildComponentNames(ir.root).size > 0)
+      return true;
+    return false;
+  }
+  hasEventsInTree(node) {
+    if (node.type === "element") {
+      const element = node;
+      if (element.events.length > 0)
+        return true;
+      for (const child of element.children) {
+        if (this.hasEventsInTree(child))
+          return true;
+      }
+    } else if (node.type === "fragment") {
+      const fragment = node;
+      for (const child of fragment.children) {
+        if (this.hasEventsInTree(child))
+          return true;
+      }
+    } else if (node.type === "conditional") {
+      const cond = node;
+      if (this.hasEventsInTree(cond.whenTrue))
+        return true;
+      if (cond.whenFalse && this.hasEventsInTree(cond.whenFalse))
+        return true;
+    } else if (node.type === "loop") {
+      const loop = node;
+      for (const child of loop.children) {
+        if (this.hasEventsInTree(child))
+          return true;
+      }
+    } else if (node.type === "if-statement") {
+      const ifStmt = node;
+      if (this.hasEventsInTree(ifStmt.consequent))
+        return true;
+      if (ifStmt.alternate && this.hasEventsInTree(ifStmt.alternate))
+        return true;
+    }
+    return false;
+  }
+  findChildComponentNames(node) {
+    const names = new Set;
+    this.collectChildComponentNames(node, names);
+    return names;
+  }
+  collectChildComponentNames(node, names) {
+    if (node.type === "component") {
+      const comp = node;
+      names.add(comp.name);
+    } else if (node.type === "element") {
+      const element = node;
+      for (const child of element.children) {
+        this.collectChildComponentNames(child, names);
+      }
+    } else if (node.type === "fragment") {
+      const fragment = node;
+      for (const child of fragment.children) {
+        this.collectChildComponentNames(child, names);
+      }
+    } else if (node.type === "conditional") {
+      const cond = node;
+      this.collectChildComponentNames(cond.whenTrue, names);
+      if (cond.whenFalse) {
+        this.collectChildComponentNames(cond.whenFalse, names);
+      }
+    } else if (node.type === "loop") {
+      const loop = node;
+      for (const child of loop.children) {
+        this.collectChildComponentNames(child, names);
+      }
+    } else if (node.type === "if-statement") {
+      const ifStmt = node;
+      this.collectChildComponentNames(ifStmt.consequent, names);
+      if (ifStmt.alternate) {
+        this.collectChildComponentNames(ifStmt.alternate, names);
+      }
+    }
+  }
+  checkImportedLoopChildComponents(ir) {
+    const relativeImports = new Set;
+    for (const imp of ir.metadata.templateImports ?? ir.metadata.imports ?? []) {
+      if (!imp.source.startsWith("./") && !imp.source.startsWith("../"))
+        continue;
+      if (imp.isTypeOnly)
+        continue;
+      for (const spec of imp.specifiers) {
+        relativeImports.add(spec.alias ?? spec.name);
+      }
+    }
+    if (relativeImports.size === 0)
+      return;
+    const 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 Go template adapter emits a cross-template call ({{template "${comp.name}" .}}); the child template must be registered on the same *template.Template instance at render time.`,
+              loc: comp.loc ?? this.makeLoc(),
+              suggestion: {
+                message: `Options:
+` + `  1. Compile '${comp.name}' (its source file) with the same adapter and register the resulting {{define "${comp.name}"}} on the same *template.Template instance 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": {
+          const el = node;
+          for (const child of el.children)
+            visit(child, inLoop);
+          break;
+        }
+        case "fragment": {
+          const frag = node;
+          for (const child of frag.children)
+            visit(child, inLoop);
+          break;
+        }
+        case "conditional": {
+          const cond = node;
+          visit(cond.whenTrue, inLoop);
+          if (cond.whenFalse)
+            visit(cond.whenFalse, inLoop);
+          break;
+        }
+        case "loop": {
+          const loop = node;
+          for (const child of loop.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": {
+          const p = node;
+          for (const child of p.children)
+            visit(child, inLoop);
+          break;
+        }
+        case "async": {
+          const a = node;
+          visit(a.fallback, inLoop);
+          for (const child of a.children)
+            visit(child, inLoop);
+          break;
+        }
+      }
+    };
+    visit(ir.root, false);
+  }
+  generateScriptRegistrations(ir, scriptBaseName) {
+    const hasInteractivity = this.hasClientInteractivity(ir);
+    if (!hasInteractivity) {
+      return "";
+    }
+    const registrations = [];
+    registrations.push(`{{.Scripts.Register "${this.options.barefootJsPath}"}}`);
+    const scriptName = scriptBaseName || ir.metadata.componentName;
+    registrations.push(`{{.Scripts.Register "${this.options.clientJsBasePath}${scriptName}.client.js"}}`);
+    return `{{if .Scripts}}${registrations.join("")}{{end}}
+`;
+  }
+  generateTypes(ir) {
+    this.usesHtmlTemplate = false;
+    const lines = [];
+    const componentName = ir.metadata.componentName;
+    this.localTypeNames = new Set;
+    this.localTypeAliases = new Map;
+    for (const td of ir.metadata.typeDefinitions) {
+      if (td.name === "Props" || td.name === `${componentName}Props`)
+        continue;
+      if (td.name.endsWith("Props"))
+        continue;
+      this.localTypeNames.add(td.name);
+      if (td.definition.match(/^type \w+ = ('[^']*'(\s*\|\s*'[^']*')*)/)) {
+        this.localTypeAliases.set(td.name, "string");
+      }
+    }
+    for (const td of ir.metadata.typeDefinitions) {
+      if (td.name === "Props" || td.name === `${componentName}Props`)
+        continue;
+      if (td.name.endsWith("Props"))
+        continue;
+      const goStruct = this.typeDefinitionToGo(td);
+      if (goStruct) {
+        lines.push(goStruct);
+        lines.push("");
+      }
+    }
+    const nestedComponents = this.findNestedComponents(ir.root);
+    const propTypeOverrides = this.buildPropTypeOverrides(ir);
+    const spreadSlots = this.collectSpreadSlots(ir.root);
+    this.generateInputStruct(lines, ir, componentName, nestedComponents, propTypeOverrides, spreadSlots);
+    this.generatePropsStruct(lines, ir, componentName, nestedComponents, propTypeOverrides, spreadSlots);
+    this.generateNewPropsFunction(lines, ir, componentName, nestedComponents, spreadSlots);
+    const header = [];
+    header.push(`package ${this.options.packageName}`);
+    header.push("");
+    header.push("import (");
+    if (this.usesHtmlTemplate)
+      header.push('\t"html/template"');
+    header.push('\t"math/rand"');
+    header.push("");
+    header.push('\tbf "github.com/barefootjs/runtime/bf"');
+    header.push(")");
+    header.push("");
+    return [...header, ...lines].join(`
+`);
+  }
+  typeDefinitionToGo(td) {
+    const def = td.definition;
+    if (def.match(/^type \w+ = ('[^']*'(\s*\|\s*'[^']*')*)/)) {
+      return `// ${td.name} is a string type.
+type ${td.name} = string`;
+    }
+    const bodyMatch = def.match(/(?:type \w+ = |interface \w+ )\{([\s\S]*)\}/);
+    if (!bodyMatch)
+      return null;
+    const body = bodyMatch[1];
+    const goFields = [];
+    const fieldEntries = body.split(/[;\n]/).map((s) => s.trim()).filter(Boolean);
+    for (const entry of fieldEntries) {
+      const fieldMatch = entry.match(/^(\w+)\??\s*:\s*(.+)$/);
+      if (!fieldMatch)
+        continue;
+      const [, fieldName, tsType] = fieldMatch;
+      const goFieldName = this.capitalizeFieldName(fieldName);
+      const goType = this.tsTypeStringToGo(tsType.trim());
+      const jsonTag = this.toJsonTag(fieldName);
+      goFields.push(`	${goFieldName} ${goType} \`json:"${jsonTag}"\``);
+    }
+    if (goFields.length === 0)
+      return null;
+    return `// ${td.name} represents a ${td.name.toLowerCase()}.
+type ${td.name} struct {
+${goFields.join(`
+`)}
+}`;
+  }
+  tsTypeStringToGo(tsType) {
+    const t = tsType.trim();
+    if (t === "number")
+      return "int";
+    if (t === "string")
+      return "string";
+    if (t === "boolean" || t === "bool")
+      return "bool";
+    if (t.endsWith("[]")) {
+      const elem = t.slice(0, -2);
+      return `[]${this.tsTypeStringToGo(elem)}`;
+    }
+    const arrayMatch = t.match(/^Array<(.+)>$/);
+    if (arrayMatch)
+      return `[]${this.tsTypeStringToGo(arrayMatch[1])}`;
+    if (this.localTypeNames.has(t))
+      return t;
+    return "interface{}";
+  }
+  buildPropTypeOverrides(ir) {
+    const overrides = new Map;
+    for (const signal of ir.metadata.signals) {
+      const propNames = [signal.initialValue];
+      const extracted = this.extractPropNameFromInitialValue(signal.initialValue);
+      if (extracted)
+        propNames.push(extracted);
+      for (const propName of propNames) {
+        const param = ir.metadata.propsParams.find((p) => p.name === propName);
+        if (!param)
+          continue;
+        const propGoType = this.typeInfoToGo(param.type, param.defaultValue);
+        if (propGoType.includes("interface{}")) {
+          const signalGoType = this.typeInfoToGo(signal.type, signal.initialValue);
+          if (!signalGoType.includes("interface{}")) {
+            overrides.set(propName, signalGoType);
+          }
+        }
+      }
+    }
+    return overrides;
+  }
+  generateInputStruct(lines, ir, componentName, nestedComponents, propTypeOverrides, spreadSlots) {
+    const inputTypeName = `${componentName}Input`;
+    lines.push(`// ${inputTypeName} is the user-facing input type.`);
+    lines.push(`type ${inputTypeName} struct {`);
+    lines.push("\tScopeID string // Optional: if empty, random ID is generated");
+    lines.push("\tBfParent string // Optional: parent scope id");
+    lines.push("\tBfMount string // Optional: slot id in parent");
+    const staticNested = nestedComponents.filter((n) => !n.isDynamic);
+    const nestedArrayFields = new Set(nestedComponents.map((n) => `${n.name}s`));
+    for (const param of ir.metadata.propsParams) {
+      const fieldName = this.capitalizeFieldName(param.name);
+      if (nestedArrayFields.has(fieldName))
+        continue;
+      const goType = propTypeOverrides.get(param.name) ?? this.typeInfoToGo(param.type, param.defaultValue);
+      lines.push(`	${fieldName} ${goType}`);
+    }
+    for (const nested of staticNested) {
+      lines.push(`	${nested.name}s []${nested.name}Input`);
+    }
+    const restPropsName = ir.metadata.restPropsName;
+    if (restPropsName) {
+      const seen = new Set;
+      for (const slot of spreadSlots) {
+        if (slot.bagSource !== "input-bag")
+          continue;
+        const fieldName = this.capitalizeFieldName(restPropsName);
+        if (seen.has(fieldName))
+          continue;
+        seen.add(fieldName);
+        const jsonTag = this.toJsonTag(restPropsName);
+        lines.push(`	${fieldName} map[string]any \`json:"${jsonTag}"\``);
+      }
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  generatePropsStruct(lines, ir, componentName, nestedComponents, propTypeOverrides, spreadSlots) {
+    const propsTypeName = `${componentName}Props`;
+    lines.push(`// ${propsTypeName} is the props type for the ${componentName} component.`);
+    lines.push(`type ${propsTypeName} struct {`);
+    lines.push('\tScopeID string `json:"scopeID"`');
+    lines.push('\tBfIsRoot bool `json:"-"`');
+    lines.push('\tBfIsChild bool `json:"-"`');
+    lines.push('\tBfParent string `json:"-"`');
+    lines.push('\tBfMount string `json:"-"`');
+    lines.push('\tScripts *bf.ScriptCollector `json:"-"`');
+    const nestedArrayFields = new Set(nestedComponents.map((n) => `${n.name}s`));
+    const propFieldNames = new Set;
+    for (const param of ir.metadata.propsParams) {
+      const fieldName = this.capitalizeFieldName(param.name);
+      if (nestedArrayFields.has(fieldName))
+        continue;
+      const goType = propTypeOverrides.get(param.name) ?? this.typeInfoToGo(param.type, param.defaultValue);
+      const jsonTag = this.toJsonTag(param.name);
+      lines.push(`	${fieldName} ${goType} \`json:"${jsonTag}"\``);
+      propFieldNames.add(fieldName);
+    }
+    const propsParamMap = new Map(ir.metadata.propsParams.map((p) => [p.name, p]));
+    for (const signal of ir.metadata.signals) {
+      const fieldName = this.capitalizeFieldName(signal.getter);
+      if (propFieldNames.has(fieldName))
+        continue;
+      const jsonTag = this.toJsonTag(signal.getter);
+      let goType;
+      let referencedProp = propsParamMap.get(signal.initialValue);
+      if (!referencedProp) {
+        const propName = this.extractPropNameFromInitialValue(signal.initialValue);
+        if (propName)
+          referencedProp = propsParamMap.get(propName);
+      }
+      if (referencedProp) {
+        const propGoType = this.typeInfoToGo(referencedProp.type, referencedProp.defaultValue);
+        const signalGoType = this.typeInfoToGo(signal.type, signal.initialValue);
+        if (propGoType.includes("interface{}")) {
+          goType = signalGoType;
+        } else if (!signalGoType.includes("interface{}") && signalGoType !== propGoType) {
+          goType = signalGoType;
+        } else {
+          goType = propGoType;
+        }
+      } else {
+        goType = this.typeInfoToGo(signal.type, signal.initialValue);
+      }
+      lines.push(`	${fieldName} ${goType} \`json:"${jsonTag}"\``);
+    }
+    for (const memo of ir.metadata.memos) {
+      const fieldName = this.capitalizeFieldName(memo.name);
+      const jsonTag = this.toJsonTag(memo.name);
+      const goType = this.inferMemoType(memo, ir.metadata.signals, propsParamMap);
+      lines.push(`	${fieldName} ${goType} \`json:"${jsonTag}"\``);
+    }
+    for (const nested of nestedComponents) {
+      if (nested.isDynamic) {
+        lines.push(`	${nested.name}s []${nested.name}Props \`json:"-"\``);
+      } else {
+        const jsonTag = this.toJsonTag(`${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`);
+        lines.push(`	${nested.name}s []${nested.name}Props \`json:"${jsonTag}"\``);
+      }
+    }
+    const staticChildren = this.collectStaticChildInstances(ir.root);
+    for (const child of staticChildren) {
+      lines.push(`	${child.fieldName} ${child.name}Props \`json:"-"\``);
+    }
+    for (const slot of spreadSlots) {
+      const jsonTag = this.toJsonTag(slot.slotId);
+      lines.push(`	${slot.slotId} map[string]any \`json:"${jsonTag}"\``);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  generateNewPropsFunction(lines, ir, componentName, nestedComponents, spreadSlots) {
+    const inputTypeName = `${componentName}Input`;
+    const propsTypeName = `${componentName}Props`;
+    const dynamicNested = nestedComponents.filter((n) => n.isDynamic);
+    lines.push(`// New${componentName}Props creates ${propsTypeName} from ${inputTypeName}.`);
+    for (const nested of dynamicNested) {
+      const arrayField = `${nested.name}s`;
+      lines.push(`//`);
+      lines.push(`// NOTE: \`${arrayField}\` is populated by the route handler, not by`);
+      lines.push(`// New${componentName}Props — the SSR template iterates over it`);
+      lines.push(`// dynamically (\`.${arrayField}\`). Build the slice from your source data and`);
+      lines.push(`// assign it before passing the props to your renderer. Example:`);
+      lines.push(`//`);
+      lines.push(`//   props := New${componentName}Props(${inputTypeName}{ /* ... */ })`);
+      lines.push(`//   props.${arrayField} = make([]${nested.name}Props, len(items))`);
+      lines.push(`//   for i, item := range items {`);
+      lines.push(`//     props.${arrayField}[i] = New${nested.name}Props(${nested.name}Input{ /* fields */ })`);
+      lines.push(`//     props.${arrayField}[i].BfParent = props.ScopeID`);
+      lines.push(`//     props.${arrayField}[i].BfMount = "${nested.slotId}"`);
+      lines.push(`//   }`);
+    }
+    lines.push(`func New${componentName}Props(in ${inputTypeName}) ${propsTypeName} {`);
+    lines.push("\tscopeID := in.ScopeID");
+    lines.push('\tif scopeID == "" {');
+    lines.push(`		scopeID = "${componentName}_" + randomID(6)`);
+    lines.push("\t}");
+    lines.push("");
+    const staticNested = nestedComponents.filter((n) => !n.isDynamic);
+    if (staticNested.length > 0) {
+      for (const nested of staticNested) {
+        const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`;
+        lines.push(`	${varName} := make([]${nested.name}Props, len(in.${nested.name}s))`);
+        lines.push(`	for i, item := range in.${nested.name}s {`);
+        lines.push(`		${varName}[i] = New${nested.name}Props(item)`);
+        lines.push(`		${varName}[i].BfParent = scopeID`);
+        lines.push(`		${varName}[i].BfMount = "${nested.slotId}"`);
+        lines.push("\t}");
+        lines.push("");
+      }
+    }
+    const propFallbackVars = this.collectPropFallbackVars(ir);
+    for (const [, info] of propFallbackVars) {
+      lines.push(`	${info.varName} := in.${info.fieldName}`);
+      lines.push(`	if ${info.varName} == ${info.zeroLiteral} {`);
+      lines.push(`		${info.varName} = ${info.goFallback}`);
+      lines.push(`	}`);
+    }
+    if (propFallbackVars.size > 0)
+      lines.push("");
+    lines.push(`	return ${propsTypeName}{`);
+    lines.push("\t\tScopeID: scopeID,");
+    lines.push("\t\tBfParent: in.BfParent,");
+    lines.push("\t\tBfMount: in.BfMount,");
+    const nestedArrayFields = new Set(nestedComponents.map((n) => `${n.name}s`));
+    const propFieldNames = new Set;
+    for (const param of ir.metadata.propsParams) {
+      const fieldName = this.capitalizeFieldName(param.name);
+      if (nestedArrayFields.has(fieldName))
+        continue;
+      const hoisted = propFallbackVars.get(param.name);
+      if (hoisted) {
+        lines.push(`		${fieldName}: ${hoisted.varName},`);
+      } else {
+        const fallback = this.goPropDefault(param.defaultValue);
+        if (fallback !== null) {
+          lines.push(`		${fieldName}: ${this.applyGoFallback(`in.${fieldName}`, fallback)},`);
+        } else {
+          lines.push(`		${fieldName}: in.${fieldName},`);
+        }
+      }
+      propFieldNames.add(fieldName);
+    }
+    for (const signal of ir.metadata.signals) {
+      const fieldName = this.capitalizeFieldName(signal.getter);
+      if (propFieldNames.has(fieldName))
+        continue;
+      const fallbackMatch = this.extractPropFallback(signal.initialValue);
+      const hoisted = fallbackMatch ? propFallbackVars.get(fallbackMatch.propName) : undefined;
+      if (hoisted) {
+        lines.push(`		${fieldName}: ${hoisted.varName},`);
+      } else {
+        const initialValue = this.convertInitialValue(signal.initialValue, signal.type, ir.metadata.propsParams);
+        lines.push(`		${fieldName}: ${initialValue},`);
+      }
+    }
+    for (const nested of staticNested) {
+      const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`;
+      lines.push(`		${nested.name}s: ${varName},`);
+    }
+    for (const memo of ir.metadata.memos) {
+      const fieldName = this.capitalizeFieldName(memo.name);
+      const memoValue = this.computeMemoInitialValue(memo, ir.metadata.signals, ir.metadata.propsParams, propFallbackVars);
+      lines.push(`		${fieldName}: ${memoValue},`);
+    }
+    const staticChildren = this.collectStaticChildInstances(ir.root);
+    for (const child of staticChildren) {
+      lines.push(`		${child.fieldName}: New${child.name}Props(${child.name}Input{`);
+      lines.push(`			ScopeID: scopeID + "_${child.slotId}",`);
+      lines.push(`			BfParent: scopeID,`);
+      lines.push(`			BfMount: "${child.slotId}",`);
+      for (const prop of child.props) {
+        switch (prop.value.kind) {
+          case "literal":
+            lines.push(`			${this.capitalizeFieldName(prop.name)}: ${this.goLiteral(prop.value.value)},`);
+            break;
+          case "boolean-shorthand":
+          case "boolean-attr":
+            lines.push(`			${this.capitalizeFieldName(prop.name)}: true,`);
+            break;
+          case "expression":
+          case "spread":
+          case "template": {
+            const parts = prop.value.kind === "template" || prop.value.kind === "expression" ? prop.value.parts : undefined;
+            if (parts) {
+              const goExpr = this.templatePartsToGoCode(parts, ir.metadata.propsParams);
+              if (goExpr !== null) {
+                lines.push(`			${this.capitalizeFieldName(prop.name)}: ${goExpr},`);
+                break;
+              }
+            }
+            const exprText = prop.value.kind === "template" ? "" : prop.value.expr;
+            if (!exprText)
+              break;
+            const resolvedValue = this.resolveDynamicPropValue(exprText, ir.metadata.signals, ir.metadata.memos, ir.metadata.propsParams);
+            if (resolvedValue !== null) {
+              lines.push(`			${this.capitalizeFieldName(prop.name)}: ${resolvedValue},`);
+            }
+            break;
+          }
+          case "jsx-children":
+            break;
+        }
+      }
+      if (child.childrenText !== null) {
+        lines.push(`			Children: ${JSON.stringify(child.childrenText)},`);
+      } else if (child.childrenHtml !== null) {
+        this.usesHtmlTemplate = true;
+        lines.push(`			Children: template.HTML(${JSON.stringify(child.childrenHtml)}),`);
+      }
+      lines.push(`		}),`);
+    }
+    for (const slot of spreadSlots) {
+      const goExpr = this.buildSpreadInitializer(slot.expr, ir);
+      if (goExpr) {
+        lines.push(`		${slot.slotId}: ${goExpr},`);
+      } else {
+        this.errors.push({
+          code: "BF101",
+          severity: "error",
+          message: `JSX spread '{...${slot.expr}}' on an intrinsic element has no Go template lowering. Supported shapes: signal-getter calls (attrs()), destructured-prop identifiers ({ extras }: P with {...extras}), SolidJS-style props identifier ((props: P) with {...props}), rest-prop identifiers ({...rest}: P with {...rest})`,
+          loc: this.makeLoc(),
+          suggestion: {
+            message: "Pre-compute the spread bag as a discrete prop, or expand the spread into per-attribute props at the call site."
+          }
+        });
+      }
+    }
+    lines.push("\t}");
+    lines.push("}");
+  }
+  toJsonTag(name) {
+    return name.charAt(0).toLowerCase() + name.slice(1);
+  }
+  findNestedComponents(node) {
+    const result = [];
+    this.collectNestedComponents(node, result);
+    return result;
+  }
+  collectNestedComponents(node, result) {
+    if (node.type === "loop") {
+      const loop = node;
+      if (loop.childComponent) {
+        if (!result.some((c) => c.name === loop.childComponent.name)) {
+          result.push({
+            ...loop.childComponent,
+            isDynamic: !loop.isStaticArray
+          });
+        }
+      }
+      for (const child of loop.children) {
+        this.collectNestedComponents(child, result);
+      }
+    } else if (node.type === "element") {
+      const element = node;
+      for (const child of element.children) {
+        this.collectNestedComponents(child, result);
+      }
+    } else if (node.type === "fragment") {
+      const fragment = node;
+      for (const child of fragment.children) {
+        this.collectNestedComponents(child, result);
+      }
+    } else if (node.type === "conditional") {
+      const cond = node;
+      this.collectNestedComponents(cond.whenTrue, result);
+      if (cond.whenFalse) {
+        this.collectNestedComponents(cond.whenFalse, result);
+      }
+    }
+  }
+  collectStaticChildInstances(node) {
+    const result = [];
+    this.collectStaticChildInstancesRecursive(node, result, false);
+    return result;
+  }
+  extractTextChildren(children) {
+    if (children.length === 0)
+      return null;
+    let out = "";
+    for (const child of children) {
+      if (child.type !== "text")
+        return null;
+      out += child.value;
+    }
+    return out;
+  }
+  extractHtmlChildren(children) {
+    if (children.length === 0)
+      return null;
+    if (children.every((c) => c.type === "text"))
+      return null;
+    const html = this.renderChildren(children);
+    if (html.includes("{{"))
+      return null;
+    return html;
+  }
+  collectStaticChildInstancesRecursive(node, result, inLoop) {
+    if (node.type === "component") {
+      const comp = node;
+      if (comp.name !== "Portal" && !inLoop && comp.slotId) {
+        const suffix = slotIdToFieldSuffix(comp.slotId);
+        result.push({
+          name: comp.name,
+          slotId: comp.slotId,
+          props: comp.props,
+          fieldName: `${comp.name}${suffix}`,
+          childrenText: this.extractTextChildren(comp.children),
+          childrenHtml: this.extractHtmlChildren(comp.children)
+        });
+      }
+      if (comp.name === "Portal" && comp.children) {
+        for (const child of comp.children) {
+          this.collectStaticChildInstancesRecursive(child, result, inLoop);
+        }
+      }
+    } else if (node.type === "loop") {
+      const loop = node;
+      for (const child of loop.children) {
+        this.collectStaticChildInstancesRecursive(child, result, true);
+      }
+    } else if (node.type === "element") {
+      const element = node;
+      for (const child of element.children) {
+        this.collectStaticChildInstancesRecursive(child, result, inLoop);
+      }
+    } else if (node.type === "fragment") {
+      const fragment = node;
+      for (const child of fragment.children) {
+        this.collectStaticChildInstancesRecursive(child, result, inLoop);
+      }
+    } else if (node.type === "conditional") {
+      const cond = node;
+      this.collectStaticChildInstancesRecursive(cond.whenTrue, result, inLoop);
+      if (cond.whenFalse) {
+        this.collectStaticChildInstancesRecursive(cond.whenFalse, result, inLoop);
+      }
+    } else if (node.type === "provider") {
+      const p = node;
+      for (const child of p.children) {
+        this.collectStaticChildInstancesRecursive(child, result, inLoop);
+      }
+    } else if (node.type === "async") {
+      const a = node;
+      this.collectStaticChildInstancesRecursive(a.fallback, result, inLoop);
+      for (const child of a.children) {
+        this.collectStaticChildInstancesRecursive(child, result, inLoop);
+      }
+    }
+  }
+  collectSpreadSlots(node) {
+    const result = [];
+    this.collectSpreadSlotsRecursive(node, result);
+    return result;
+  }
+  classifySpreadBagSource(spreadExpr) {
+    const trimmed = spreadExpr.trim();
+    if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(trimmed) && this.restPropsName === trimmed) {
+      return "input-bag";
+    }
+    return "inline";
+  }
+  collectSpreadSlotsRecursive(node, result) {
+    if (node.type === "element") {
+      const element = node;
+      for (const attr of element.attrs) {
+        if (attr.value.kind !== "spread")
+          continue;
+        if (!attr.value.slotId)
+          continue;
+        result.push({
+          slotId: attr.value.slotId,
+          expr: attr.value.expr,
+          templateExpr: attr.value.templateExpr,
+          bagSource: this.classifySpreadBagSource(attr.value.expr)
+        });
+      }
+      for (const child of element.children) {
+        this.collectSpreadSlotsRecursive(child, result);
+      }
+      return;
+    }
+    if (node.type === "fragment") {
+      const fragment = node;
+      for (const child of fragment.children) {
+        this.collectSpreadSlotsRecursive(child, result);
+      }
+      return;
+    }
+    if (node.type === "conditional") {
+      const cond = node;
+      this.collectSpreadSlotsRecursive(cond.whenTrue, result);
+      if (cond.whenFalse)
+        this.collectSpreadSlotsRecursive(cond.whenFalse, result);
+      return;
+    }
+    if (node.type === "if-statement") {
+      const stmt = node;
+      this.collectSpreadSlotsRecursive(stmt.consequent, result);
+      if (stmt.alternate)
+        this.collectSpreadSlotsRecursive(stmt.alternate, result);
+      return;
+    }
+    if (node.type === "component") {
+      const comp = node;
+      for (const child of comp.children) {
+        this.collectSpreadSlotsRecursive(child, result);
+      }
+      return;
+    }
+    if (node.type === "provider") {
+      const p = node;
+      for (const child of p.children) {
+        this.collectSpreadSlotsRecursive(child, result);
+      }
+      return;
+    }
+    if (node.type === "async") {
+      const a = node;
+      this.collectSpreadSlotsRecursive(a.fallback, result);
+      for (const child of a.children) {
+        this.collectSpreadSlotsRecursive(child, result);
+      }
+      return;
+    }
+  }
+  parseJsObjectLiteralToGoMap(jsText) {
+    const sf = ts.createSourceFile("inline.ts", `(${jsText})`, ts.ScriptTarget.Latest, true);
+    if (sf.statements.length !== 1)
+      return null;
+    const stmt = sf.statements[0];
+    if (!ts.isExpressionStatement(stmt))
+      return null;
+    let expr = stmt.expression;
+    while (ts.isParenthesizedExpression(expr))
+      expr = expr.expression;
+    if (!ts.isObjectLiteralExpression(expr))
+      return null;
+    const entries = [];
+    for (const prop of expr.properties) {
+      if (!ts.isPropertyAssignment(prop))
+        return null;
+      let key;
+      if (ts.isIdentifier(prop.name)) {
+        key = prop.name.text;
+      } else if (ts.isStringLiteral(prop.name) || ts.isNoSubstitutionTemplateLiteral(prop.name)) {
+        key = prop.name.text;
+      } else {
+        return null;
+      }
+      const val = prop.initializer;
+      let goVal;
+      if (ts.isStringLiteral(val) || ts.isNoSubstitutionTemplateLiteral(val)) {
+        goVal = JSON.stringify(val.text);
+      } else if (ts.isNumericLiteral(val)) {
+        goVal = val.text;
+      } else if (ts.isPrefixUnaryExpression(val) && (val.operator === ts.SyntaxKind.MinusToken || val.operator === ts.SyntaxKind.PlusToken) && ts.isNumericLiteral(val.operand)) {
+        const sign = val.operator === ts.SyntaxKind.MinusToken ? "-" : "";
+        goVal = `${sign}${val.operand.text}`;
+      } else if (val.kind === ts.SyntaxKind.TrueKeyword) {
+        goVal = "true";
+      } else if (val.kind === ts.SyntaxKind.FalseKeyword) {
+        goVal = "false";
+      } else if (val.kind === ts.SyntaxKind.NullKeyword) {
+        goVal = "nil";
+      } else {
+        return null;
+      }
+      entries.push(`${JSON.stringify(key)}: ${goVal}`);
+    }
+    return `map[string]any{${entries.join(", ")}}`;
+  }
+  buildSpreadInitializer(spreadExpr, ir) {
+    const trimmed = spreadExpr.trim();
+    const callMatch = /^([a-zA-Z_][a-zA-Z0-9_]*)\s*\(\s*\)$/.exec(trimmed);
+    if (callMatch) {
+      const getterName = callMatch[1];
+      const signal = ir.metadata.signals.find((s) => s.getter === getterName);
+      if (signal && signal.initialValue) {
+        const goMap = this.parseJsObjectLiteralToGoMap(signal.initialValue);
+        if (goMap)
+          return goMap;
+      }
+      return null;
+    }
+    if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(trimmed)) {
+      const param = ir.metadata.propsParams.find((p) => p.name === trimmed);
+      if (param) {
+        return `in.${this.capitalizeFieldName(param.name)}`;
+      }
+      if (ir.metadata.propsObjectName === trimmed) {
+        const entries = ir.metadata.propsParams.map((p) => `${JSON.stringify(p.name)}: in.${this.capitalizeFieldName(p.name)}`);
+        return `map[string]any{${entries.join(", ")}}`;
+      }
+      if (ir.metadata.restPropsName === trimmed) {
+        return `in.${this.capitalizeFieldName(trimmed)}`;
+      }
+    }
+    return null;
+  }
+  convertInitialValue(value, typeInfo, propsParams) {
+    if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(value)) {
+      if (propsParams?.some((p) => p.name === value)) {
+        return `in.${this.capitalizeFieldName(value)}`;
+      }
+    }
+    const propName = this.extractPropNameFromInitialValue(value);
+    if (propName && propsParams?.some((p) => p.name === propName)) {
+      return `in.${this.capitalizeFieldName(propName)}`;
+    }
+    if (typeInfo.kind === "primitive") {
+      if (typeInfo.primitive === "boolean") {
+        return value === "true" ? "true" : "false";
+      }
+      if (typeInfo.primitive === "number") {
+        if (/^\d+$/.test(value))
+          return value;
+        if (/^\d+\.\d+$/.test(value))
+          return value;
+        return "0";
+      }
+      if (typeInfo.primitive === "string") {
+        if (value.startsWith("'") || value.endsWith("'")) {
+          return value.replace(/'/g, '"');
+        }
+        if (value.startsWith('"') && value.endsWith('"')) {
+          return value;
+        }
+        return '""';
+      }
+    }
+    if (typeInfo.kind === "array") {
+      if (value === "[]" || value === "null" || value === "undefined") {
+        return "nil";
+      }
+      return "nil";
+    }
+    if (typeInfo.kind === "interface" && typeInfo.raw) {
+      const aliasBase = this.localTypeAliases.get(typeInfo.raw);
+      if (aliasBase === "string") {
+        if (value.startsWith("'") || value.startsWith('"')) {
+          return value.replace(/'/g, '"');
+        }
+        return '""';
+      }
+    }
+    return "nil";
+  }
+  typeInfoToGo(typeInfo, defaultValue) {
+    switch (typeInfo.kind) {
+      case "primitive":
+        switch (typeInfo.primitive) {
+          case "string":
+            return "string";
+          case "number":
+            return "int";
+          case "boolean":
+            return "bool";
+          default:
+            return "interface{}";
+        }
+      case "array":
+        if (typeInfo.elementType) {
+          return `[]${this.typeInfoToGo(typeInfo.elementType)}`;
+        }
+        return "[]interface{}";
+      case "object":
+        return "map[string]interface{}";
+      case "interface":
+        if (typeInfo.raw && this.localTypeNames.has(typeInfo.raw)) {
+          return typeInfo.raw;
+        }
+        if (typeInfo.raw) {
+          const resolved = this.tsTypeStringToGo(typeInfo.raw);
+          if (resolved !== "interface{}")
+            return resolved;
+        }
+        return "interface{}";
+      case "unknown":
+        if (defaultValue !== undefined) {
+          return this.inferTypeFromValue(defaultValue);
+        }
+        return "interface{}";
+      default:
+        return "interface{}";
+    }
+  }
+  getSignalInitialValueAsGo(initialValue, propsParams, propFallbackVars = GoTemplateAdapter.EMPTY_PROP_FALLBACK_VARS) {
+    if (propsParams.some((p) => p.name === initialValue)) {
+      const hoisted = propFallbackVars.get(initialValue);
+      if (hoisted)
+        return hoisted.varName;
+      return `in.${this.capitalizeFieldName(initialValue)}`;
+    }
+    const propName = this.extractPropNameFromInitialValue(initialValue);
+    if (propName && propsParams.some((p) => p.name === propName)) {
+      const hoisted = propFallbackVars.get(propName);
+      if (hoisted)
+        return hoisted.varName;
+      return `in.${this.capitalizeFieldName(propName)}`;
+    }
+    if (/^-?\d+$/.test(initialValue)) {
+      return initialValue;
+    }
+    if (/^-?\d+\.\d+$/.test(initialValue)) {
+      return initialValue;
+    }
+    if (initialValue === "true" || initialValue === "false") {
+      return initialValue;
+    }
+    if (initialValue.startsWith("'") && initialValue.endsWith("'") || initialValue.startsWith('"') && initialValue.endsWith('"')) {
+      return initialValue.replace(/'/g, '"');
+    }
+    return "0";
+  }
+  templatePartsToGoCode(parts, propsParams) {
+    const segments = [];
+    for (const part of parts) {
+      if (part.type === "string") {
+        segments.push(JSON.stringify(part.value));
+        continue;
+      }
+      if (part.type === "lookup") {
+        const keyExpr = part.key.trim();
+        const param = propsParams.find((p) => p.name === keyExpr);
+        if (!param)
+          return null;
+        const fieldName = this.capitalizeFieldName(keyExpr);
+        const caseEntries = Object.entries(part.cases);
+        if (caseEntries.length === 0) {
+          segments.push('""');
+          continue;
+        }
+        const lines = [];
+        lines.push("func() string {");
+        lines.push(`			k, _ := in.${fieldName}.(string)`);
+        lines.push("\t\t\tswitch k {");
+        for (const [k, v] of caseEntries) {
+          lines.push(`			case ${JSON.stringify(k)}: return ${JSON.stringify(v)}`);
+        }
+        lines.push("\t\t\t}");
+        lines.push('\t\t\treturn ""');
+        lines.push("\t\t}()");
+        segments.push(lines.join(`
+`));
+        continue;
+      }
+      return null;
+    }
+    if (segments.length === 0)
+      return '""';
+    return segments.join(" + ");
+  }
+  resolveDynamicPropValue(expr, signals, memos, propsParams) {
+    const getterMatch = expr.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\(\)$/);
+    if (getterMatch) {
+      const getterName = getterMatch[1];
+      const signal = signals.find((s) => s.getter === getterName);
+      if (signal) {
+        return this.convertInitialValue(signal.initialValue, signal.type, propsParams);
+      }
+      const memo = memos.find((m) => m.name === getterName);
+      if (memo) {
+        return this.computeMemoInitialValue(memo, signals, propsParams);
+      }
+    }
+    return null;
+  }
+  computeMemoInitialValue(memo, signals, propsParams, propFallbackVars = GoTemplateAdapter.EMPTY_PROP_FALLBACK_VARS) {
+    const computation = memo.computation;
+    const propRef = (propName) => {
+      const hoisted = propFallbackVars.get(propName);
+      if (hoisted)
+        return hoisted.varName;
+      return `in.${this.capitalizeFieldName(propName)}`;
+    };
+    const arithmeticMatch = computation.match(/\(\)\s*=>\s*(\w+)\(\)\s*([*+\-/])\s*(\d+)/);
+    if (arithmeticMatch) {
+      const [, depName, operator, operand] = arithmeticMatch;
+      const signal = signals.find((s) => s.getter === depName);
+      if (signal) {
+        const signalInitial = this.getSignalInitialValueAsGo(signal.initialValue, propsParams, propFallbackVars);
+        return `${signalInitial} ${operator} ${operand}`;
+      }
+    }
+    const propsArithmeticMatch = computation.match(/\(\)\s*=>\s*props\.(\w+)\s*([*+\-/])\s*(\d+)/);
+    if (propsArithmeticMatch) {
+      const [, propName, operator, operand] = propsArithmeticMatch;
+      const param = propsParams.find((p) => p.name === propName);
+      if (param) {
+        const hoisted = propFallbackVars.get(propName);
+        if (hoisted)
+          return `${hoisted.varName} ${operator} ${operand}`;
+        const fieldName = this.capitalizeFieldName(propName);
+        if (param.type) {
+          const goType = this.typeInfoToGo(param.type, param.defaultValue);
+          if (goType === "interface{}")
+            return `in.${fieldName}.(int) ${operator} ${operand}`;
+        }
+        return `in.${fieldName} ${operator} ${operand}`;
+      }
+    }
+    const simpleMatch = computation.match(/\(\)\s*=>\s*(\w+)\(\)$/);
+    if (simpleMatch) {
+      const [, depName] = simpleMatch;
+      const signal = signals.find((s) => s.getter === depName);
+      if (signal) {
+        return this.getSignalInitialValueAsGo(signal.initialValue, propsParams, propFallbackVars);
+      }
+    }
+    const propsSimpleMatch = computation.match(/\(\)\s*=>\s*props\.(\w+)$/);
+    if (propsSimpleMatch) {
+      const [, propName] = propsSimpleMatch;
+      const param = propsParams.find((p) => p.name === propName);
+      if (param) {
+        return propRef(propName);
+      }
+    }
+    const varArithmeticMatch = computation.match(/\(\)\s*=>\s*(\w+)\s*([*+\-/])\s*(\d+)/);
+    if (varArithmeticMatch) {
+      const [, varName, operator, operand] = varArithmeticMatch;
+      const param = propsParams.find((p) => p.name === varName);
+      if (param) {
+        const fieldName = this.capitalizeFieldName(varName);
+        if (param.type) {
+          const goType = this.typeInfoToGo(param.type, param.defaultValue);
+          if (goType === "interface{}")
+            return `in.${fieldName}.(int) ${operator} ${operand}`;
+        }
+        return `in.${fieldName} ${operator} ${operand}`;
+      }
+    }
+    const varSimpleMatch = computation.match(/\(\)\s*=>\s*(\w+)$/);
+    if (varSimpleMatch) {
+      const [, varName] = varSimpleMatch;
+      const param = propsParams.find((p) => p.name === varName);
+      if (param) {
+        return `in.${this.capitalizeFieldName(varName)}`;
+      }
+    }
+    return "0";
+  }
+  inferMemoType(memo, signals, propsParamMap) {
+    if (memo.computation.includes("*") || memo.computation.includes("/") || memo.computation.includes("+") || memo.computation.includes("-")) {
+      for (const dep of memo.deps) {
+        const signal = signals.find((s) => s.getter === dep);
+        if (signal) {
+          let referencedProp = propsParamMap.get(signal.initialValue);
+          if (!referencedProp) {
+            const propName = this.extractPropNameFromInitialValue(signal.initialValue);
+            if (propName)
+              referencedProp = propsParamMap.get(propName);
+          }
+          if (referencedProp) {
+            const propType = this.typeInfoToGo(referencedProp.type, referencedProp.defaultValue);
+            if (propType === "int" || propType === "float64") {
+              return "int";
+            }
+          }
+          const signalType = this.typeInfoToGo(signal.type, signal.initialValue);
+          if (signalType === "int" || signalType === "float64") {
+            return "int";
+          }
+        }
+      }
+    }
+    return this.typeInfoToGo(memo.type);
+  }
+  inferTypeFromValue(value) {
+    if (value === "true" || value === "false")
+      return "bool";
+    if (/^-?\d+$/.test(value))
+      return "int";
+    if (/^-?\d+\.\d+$/.test(value))
+      return "float64";
+    if (value.startsWith("'") && value.endsWith("'") || value.startsWith('"') && value.endsWith('"')) {
+      return "string";
+    }
+    if (value === '""' || value === "''")
+      return "string";
+    if (value.startsWith("["))
+      return "[]interface{}";
+    return "interface{}";
+  }
+  static EMPTY_PROP_FALLBACK_VARS = new Map;
+  collectPropFallbackVars(ir) {
+    const result = new Map;
+    const localTaken = new Set(["scopeID"]);
+    for (const nested of this.findNestedComponents(ir.root)) {
+      localTaken.add(`${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`);
+    }
+    for (const signal of ir.metadata.signals) {
+      const match = this.extractPropFallback(signal.initialValue);
+      if (!match)
+        continue;
+      if (result.has(match.propName))
+        continue;
+      const param = ir.metadata.propsParams.find((p) => p.name === match.propName);
+      if (!param)
+        continue;
+      if (this.goPropDefault(param.defaultValue) !== null)
+        continue;
+      const fieldName = this.capitalizeFieldName(match.propName);
+      let zeroLiteral;
+      if (match.goFallback === "true" || match.goFallback === "false") {
+        zeroLiteral = "false";
+      } else if (/^-?\d+(\.\d+)?$/.test(match.goFallback)) {
+        zeroLiteral = "0";
+      } else if (match.goFallback.startsWith('"')) {
+        zeroLiteral = '""';
+      } else {
+        continue;
+      }
+      if (match.goFallback === zeroLiteral)
+        continue;
+      if (zeroLiteral === "0" && Number(match.goFallback) === 0)
+        continue;
+      let varName = match.propName;
+      while (localTaken.has(varName) || GoTemplateAdapter.GO_KEYWORDS.has(varName)) {
+        varName += "_";
+      }
+      localTaken.add(varName);
+      result.set(match.propName, { varName, fieldName, goFallback: match.goFallback, zeroLiteral });
+    }
+    return result;
+  }
+  extractPropFallback(initialValue) {
+    if (!this.propsObjectName)
+      return null;
+    const trimmed = initialValue.trim();
+    const name = this.propsObjectName;
+    const re = new RegExp(`^${name}\\.(\\w+)\\s*\\?\\?\\s*(.+)$`);
+    const m = trimmed.match(re);
+    if (!m)
+      return null;
+    const goFallback = this.goPropDefault(m[2].trim());
+    if (goFallback === null)
+      return null;
+    return { propName: m[1], goFallback };
+  }
+  extractPropNameFromInitialValue(initialValue) {
+    if (!this.propsObjectName)
+      return null;
+    const trimmed = initialValue.trim();
+    const name = this.propsObjectName;
+    const direct = new RegExp(`^${name}\\.(\\w+)(?:\\s*(?:\\?\\?|\\|\\|)\\s*.+)?$`);
+    const m1 = trimmed.match(direct);
+    if (m1)
+      return m1[1];
+    const wrapped = new RegExp(`^\\(${name}\\.(\\w+)\\s*(?:\\?\\?|\\|\\|)\\s*[^)]+\\)(.*)$`);
+    const m2 = trimmed.match(wrapped);
+    if (m2) {
+      const tail = m2[2];
+      if (/^\s*\.(length|size|some|every|includes|indexOf|findIndex|lastIndexOf)\b/.test(tail)) {
+        return null;
+      }
+      return m2[1];
+    }
+    return null;
+  }
+  static GO_INITIALISMS = new Set([
+    "id",
+    "url",
+    "http",
+    "https",
+    "api",
+    "json",
+    "xml",
+    "html",
+    "css",
+    "sql",
+    "ip",
+    "tcp",
+    "udp",
+    "dns",
+    "ssh",
+    "tls",
+    "ssl",
+    "uri",
+    "uid",
+    "uuid",
+    "ascii",
+    "utf8",
+    "eof",
+    "grpc",
+    "rpc",
+    "cpu",
+    "gpu",
+    "ram",
+    "os"
+  ]);
+  static GO_KEYWORDS = new Set([
+    "break",
+    "case",
+    "chan",
+    "const",
+    "continue",
+    "default",
+    "defer",
+    "else",
+    "fallthrough",
+    "for",
+    "func",
+    "go",
+    "goto",
+    "if",
+    "import",
+    "interface",
+    "map",
+    "package",
+    "range",
+    "return",
+    "select",
+    "struct",
+    "switch",
+    "type",
+    "var"
+  ]);
+  capitalizeFieldName(name) {
+    if (!name)
+      return name;
+    if (GoTemplateAdapter.GO_INITIALISMS.has(name.toLowerCase())) {
+      return name.toUpperCase();
+    }
+    return name.charAt(0).toUpperCase() + name.slice(1);
+  }
+  goPropDefault(defaultValue) {
+    if (!defaultValue)
+      return null;
+    const trimmed = defaultValue.trim();
+    if (trimmed === "")
+      return null;
+    if (trimmed === "true" || trimmed === "false")
+      return trimmed;
+    if (/^-?\d+(\.\d+)?$/.test(trimmed))
+      return trimmed;
+    if (trimmed.startsWith("'") && trimmed.endsWith("'") || trimmed.startsWith('"') && trimmed.endsWith('"')) {
+      const body = trimmed.slice(1, -1);
+      return JSON.stringify(body);
+    }
+    return null;
+  }
+  applyGoFallback(ref, fallback) {
+    if (fallback === "true" || fallback === "false") {
+      return fallback === "true" ? `(${ref} || true)` : ref;
+    }
+    if (/^-?\d+(\.\d+)?$/.test(fallback)) {
+      if (fallback === "0")
+        return ref;
+      return `func() int { if ${ref} == 0 { return ${fallback} }; return ${ref} }()`;
+    }
+    return `func() string { if ${ref} == "" { return ${fallback} }; return ${ref} }()`;
+  }
+  goLiteral(value) {
+    if (value === "true" || value === "false")
+      return value;
+    if (/^-?\d+(\.\d+)?$/.test(value))
+      return value;
+    if (value.startsWith("'") && value.endsWith("'")) {
+      return `"${value.slice(1, -1)}"`;
+    }
+    if (value.startsWith('"') && value.endsWith('"')) {
+      return value;
+    }
+    return `"${value}"`;
+  }
+  renderNode(node, ctx) {
+    return emitIRNode(node, this, ctx ?? {});
+  }
+  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, ctx);
+  }
+  emitFragment(node, _ctx, _emit) {
+    return this.renderFragment(node);
+  }
+  emitSlot(node) {
+    return this.renderSlot(node);
+  }
+  emitIfStatement(node, ctx, _emit) {
+    return this.renderIfStatement(node, ctx);
+  }
+  emitProvider(node, _ctx, _emit) {
+    return this.renderChildren(node.children);
+  }
+  emitAsync(node, _ctx, _emit) {
+    return this.renderAsync(node);
+  }
+  renderElement(element) {
+    const tag = element.tag;
+    const attrs = this.renderAttributes(element);
+    const children = this.renderChildren(element.children);
+    let hydrationAttrs = "";
+    if (element.needsScope) {
+      hydrationAttrs += ` ${this.renderScopeMarker(".ScopeID")}`;
+    }
+    if (element.slotId) {
+      hydrationAttrs += ` ${this.renderSlotMarker(element.slotId)}`;
+    }
+    const voidElements = [
+      "area",
+      "base",
+      "br",
+      "col",
+      "embed",
+      "hr",
+      "img",
+      "input",
+      "link",
+      "meta",
+      "param",
+      "source",
+      "track",
+      "wbr"
+    ];
+    if (voidElements.includes(tag.toLowerCase())) {
+      return `<${tag}${attrs}${hydrationAttrs}>`;
+    }
+    return `<${tag}${attrs}${hydrationAttrs}>${children}</${tag}>`;
+  }
+  renderExpression(expr) {
+    if (expr.clientOnly) {
+      if (expr.slotId) {
+        return `{{bfComment "client:${expr.slotId}"}}`;
+      }
+      return "";
+    }
+    const goExpr = this.convertExpressionToGo(expr.expr);
+    if (goExpr.startsWith("{{")) {
+      if (expr.slotId) {
+        return `{{bfTextStart "${expr.slotId}"}}${goExpr}{{bfTextEnd}}`;
+      }
+      return goExpr;
+    }
+    if (expr.slotId) {
+      return `{{bfTextStart "${expr.slotId}"}}{{${goExpr}}}{{bfTextEnd}}`;
+    }
+    return `{{${goExpr}}}`;
+  }
+  renderClientOnlyConditional(cond) {
+    if (cond.slotId) {
+      return `{{bfComment "cond-start:${cond.slotId}"}}{{bfComment "cond-end:${cond.slotId}"}}`;
+    }
+    return "";
+  }
+  renderParsedExpr(expr) {
+    return emitParsedExpr(expr, this);
+  }
+  identifier(name) {
+    return `.${this.capitalizeFieldName(name)}`;
+  }
+  literal(value, literalType) {
+    if (literalType === "string")
+      return `"${value}"`;
+    if (literalType === "null")
+      return '""';
+    return String(value);
+  }
+  call(callee, args, emit) {
+    if (callee.kind === "identifier" && args.length === 0) {
+      return `.${this.capitalizeFieldName(callee.name)}`;
+    }
+    const path = identifierPath(callee);
+    if (path && this.templatePrimitives[path]) {
+      const expected = this.templatePrimitiveArities[path];
+      if (expected === undefined || args.length === expected) {
+        const renderedArgs = args.map(emit);
+        return `(${this.templatePrimitives[path](renderedArgs)})`;
+      }
+      this.errors.push({
+        code: "BF101",
+        severity: "error",
+        message: `templatePrimitive '${path}' expects ${expected} arg(s), got ${args.length}`,
+        loc: this.makeLoc(),
+        suggestion: {
+          message: `Call '${path}' with exactly ${expected} argument(s), or wrap the JSX expression in /* @client */ to defer evaluation.`
+        }
+      });
+    }
+    const calleeStr = emit(callee);
+    if (args.length === 0)
+      return calleeStr;
+    const argsStr = args.map(emit).join(" ");
+    return `${calleeStr} ${argsStr}`;
+  }
+  member(object, property, _computed, emit) {
+    if (property === "length" && object.kind === "higher-order") {
+      const result = this.renderFilterLengthExpr(object, emit);
+      if (result)
+        return result;
+    }
+    if (object.kind === "higher-order" && object.method === "find") {
+      const findResult = this.renderHigherOrderExpr(object, emit);
+      if (findResult) {
+        return `{{with ${findResult}}}{{.${this.capitalizeFieldName(property)}}}{{end}}`;
+      }
+      const templateBlock = this.renderFindTemplateBlock(object, emit, this.capitalizeFieldName(property));
+      if (templateBlock)
+        return templateBlock;
+    }
+    if (object.kind === "identifier" && this.propsObjectName && object.name === this.propsObjectName) {
+      return `.${this.capitalizeFieldName(property)}`;
+    }
+    const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1];
+    if (object.kind === "identifier" && currentLoopParam && object.name === currentLoopParam) {
+      return `.${this.capitalizeFieldName(property)}`;
+    }
+    const obj = emit(object);
+    if (property === "length")
+      return `len ${obj}`;
+    return `${obj}.${this.capitalizeFieldName(property)}`;
+  }
+  binary(op, left, right, emit) {
+    const l = emit(left);
+    const r = emit(right);
+    switch (op) {
+      case "===":
+      case "==":
+        return `eq ${l} ${r}`;
+      case "!==":
+      case "!=":
+        return `ne ${l} ${r}`;
+      case ">":
+        return `gt ${l} ${r}`;
+      case "<":
+        return `lt ${l} ${r}`;
+      case ">=":
+        return `ge ${l} ${r}`;
+      case "<=":
+        return `le ${l} ${r}`;
+      case "+":
+        return `bf_add ${l} ${r}`;
+      case "-":
+        return `bf_sub ${l} ${r}`;
+      case "*":
+        return `bf_mul ${l} ${r}`;
+      case "/":
+        return `bf_div ${l} ${r}`;
+      case "%":
+        return `bf_mod ${l} ${r}`;
+      default:
+        return `${l} ${op} ${r}`;
+    }
+  }
+  unary(op, argument, emit) {
+    const arg = emit(argument);
+    if (op === "!")
+      return `not ${arg}`;
+    if (op === "-")
+      return `bf_neg ${arg}`;
+    return arg;
+  }
+  logical(op, left, right, emit) {
+    const l = emit(left);
+    const r = emit(right);
+    const wrapLeft = this.needsParens(left) ? `(${l})` : l;
+    const wrapRight = this.needsParens(right) ? `(${r})` : r;
+    if (op === "&&")
+      return `and ${wrapLeft} ${wrapRight}`;
+    return `or ${wrapLeft} ${wrapRight}`;
+  }
+  conditional(test, consequent, alternate, emit) {
+    const t = emit(test);
+    const c = this.renderConditionalBranch(consequent);
+    const a = this.renderConditionalBranch(alternate);
+    return `{{if ${t}}}${c}{{else}}${a}{{end}}`;
+  }
+  templateLiteral(parts, emit) {
+    let result = "";
+    for (const part of parts) {
+      if (part.type === "string") {
+        result += part.value;
+      } else {
+        result += `{{${emit(part.expr)}}}`;
+      }
+    }
+    return result;
+  }
+  arrowFn(param, _body, _emit) {
+    return `[ARROW-FN: ${param} => ...]`;
+  }
+  arrayLiteral(elements, emit) {
+    if (elements.length === 0)
+      return "bf_arr";
+    const parts = elements.map((el) => {
+      const rendered = emit(el);
+      return rendered.includes(" ") ? `(${rendered})` : rendered;
+    });
+    return `bf_arr ${parts.join(" ")}`;
+  }
+  higherOrder(method, object, param, predicate, emit) {
+    const reconstructed = { kind: "higher-order", method, object, param, predicate };
+    const result = this.renderHigherOrderExpr(reconstructed, emit);
+    if (result)
+      return result;
+    if (method === "find" || method === "findIndex") {
+      const templateBlock = this.renderFindTemplateBlock(reconstructed, emit);
+      if (templateBlock)
+        return templateBlock;
+    }
+    if (method === "every" || method === "some") {
+      const templateBlock = this.renderEverySomeTemplateBlock(reconstructed, emit);
+      if (templateBlock)
+        return templateBlock;
+    }
+    this.errors.push({
+      code: "BF101",
+      severity: "error",
+      message: `Higher-order method '.${method}' shape cannot be lowered to a Go template action`,
+      loc: this.makeLoc(),
+      suggestion: {
+        message: `Options:
+1. Use @client directive for client-side evaluation
+2. Pre-compute the value in Go code`
+      }
+    });
+    return `""`;
+  }
+  arrayMethod(method, object, args, emit) {
+    switch (method) {
+      case "join": {
+        const obj = emit(object);
+        const sep = emit(args[0]);
+        return `bf_join (${obj}) ${wrapIfMultiToken(sep)}`;
+      }
+      case "includes": {
+        const obj = emit(object);
+        const needle = emit(args[0]);
+        return `bf_includes ${wrapIfMultiToken(obj)} ${wrapIfMultiToken(needle)}`;
+      }
+      case "indexOf":
+      case "lastIndexOf": {
+        const fn = method === "indexOf" ? "bf_index_of" : "bf_last_index_of";
+        const obj = emit(object);
+        const needle = emit(args[0]);
+        return `${fn} ${wrapIfMultiToken(obj)} ${wrapIfMultiToken(needle)}`;
+      }
+      case "at": {
+        const obj = emit(object);
+        const idx = emit(args[0]);
+        return `bf_at ${wrapIfMultiToken(obj)} ${wrapIfMultiToken(idx)}`;
+      }
+      case "concat": {
+        const a = emit(object);
+        const b = emit(args[0]);
+        return `bf_concat ${wrapIfMultiToken(a)} ${wrapIfMultiToken(b)}`;
+      }
+      case "slice": {
+        const recv = emit(object);
+        const start = emit(args[0]);
+        if (args.length === 1) {
+          return `bf_slice ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(start)}`;
+        }
+        const end = emit(args[1]);
+        return `bf_slice ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(start)} ${wrapIfMultiToken(end)}`;
+      }
+      case "reverse":
+      case "toReversed": {
+        const recv = emit(object);
+        return `bf_reverse ${wrapIfMultiToken(recv)}`;
+      }
+      case "toLowerCase": {
+        const recv = emit(object);
+        return `bf_lower ${wrapIfMultiToken(recv)}`;
+      }
+      case "toUpperCase": {
+        const recv = emit(object);
+        return `bf_upper ${wrapIfMultiToken(recv)}`;
+      }
+      case "trim": {
+        const recv = emit(object);
+        return `bf_trim ${wrapIfMultiToken(recv)}`;
+      }
+      default: {
+        const _exhaustive = method;
+        throw new Error(`Go arrayMethod: unhandled ArrayMethod '${_exhaustive}'`);
+      }
+    }
+  }
+  sortMethod(method, object, comparator, emit) {
+    return emitBfSort(emit(object), comparator);
+  }
+  unsupported(raw, _reason) {
+    return `[UNSUPPORTED: ${raw}]`;
+  }
+  extractFieldPredicate(pred, param) {
+    if (pred.kind === "member" && pred.object.kind === "identifier" && pred.object.name === param) {
+      return { field: this.capitalizeFieldName(pred.property), negated: false };
+    }
+    if (pred.kind === "unary" && pred.op === "!" && pred.argument.kind === "member") {
+      const mem = pred.argument;
+      if (mem.object.kind === "identifier" && mem.object.name === param) {
+        return { field: this.capitalizeFieldName(mem.property), negated: true };
+      }
+    }
+    return { field: null, negated: false };
+  }
+  extractEqualityPredicate(pred, param, renderValue) {
+    if (pred.kind === "member" && pred.object.kind === "identifier" && pred.object.name === param) {
+      return { field: this.capitalizeFieldName(pred.property), value: "true" };
+    }
+    if (pred.kind === "unary" && pred.op === "!" && pred.argument.kind === "member") {
+      const mem = pred.argument;
+      if (mem.object.kind === "identifier" && mem.object.name === param) {
+        return { field: this.capitalizeFieldName(mem.property), value: "false" };
+      }
+    }
+    if (pred.kind === "binary" && (pred.op === "===" || pred.op === "==")) {
+      if (pred.left.kind === "member" && pred.left.object.kind === "identifier" && pred.left.object.name === param) {
+        return { field: this.capitalizeFieldName(pred.left.property), value: renderValue(pred.right) };
+      }
+      if (pred.right.kind === "member" && pred.right.object.kind === "identifier" && pred.right.object.name === param) {
+        return { field: this.capitalizeFieldName(pred.right.property), value: renderValue(pred.left) };
+      }
+    }
+    return null;
+  }
+  renderHigherOrderExpr(expr, renderArray) {
+    const arrayExpr = renderArray(expr.object);
+    if (expr.method === "every" || expr.method === "some") {
+      const { field } = this.extractFieldPredicate(expr.predicate, expr.param);
+      if (!field)
+        return null;
+      return expr.method === "every" ? `bf_every ${arrayExpr} "${field}"` : `bf_some ${arrayExpr} "${field}"`;
+    }
+    if (expr.method === "filter") {
+      if (expr.predicate.kind === "identifier" && expr.predicate.name === expr.param) {
+        return `bf_filter_truthy (${arrayExpr})`;
+      }
+      const { field, negated } = this.extractFieldPredicate(expr.predicate, expr.param);
+      if (!field)
+        return null;
+      const value = negated ? "false" : "true";
+      return `bf_filter ${arrayExpr} "${field}" ${value}`;
+    }
+    if (expr.method === "find" || expr.method === "findIndex") {
+      const eqPred = this.extractEqualityPredicate(expr.predicate, expr.param, (e) => this.renderParsedExpr(e));
+      if (!eqPred)
+        return null;
+      const func = expr.method === "find" ? "bf_find" : "bf_find_index";
+      return `${func} ${arrayExpr} "${eqPred.field}" ${eqPred.value}`;
+    }
+    return null;
+  }
+  renderFindTemplateBlock(expr, renderArray, propertyAccess) {
+    const arrayExpr = renderArray(expr.object);
+    const condition = this.renderFilterExpr(expr.predicate, expr.param);
+    if (condition.includes("[UNSUPPORTED"))
+      return null;
+    if (expr.method === "find") {
+      const output = propertyAccess ? `{{.${propertyAccess}}}` : "{{.}}";
+      return `{{range ${arrayExpr}}}{{if ${condition}}}${output}{{break}}{{end}}{{end}}`;
+    }
+    if (expr.method === "findIndex") {
+      return `{{range $i, $_ := ${arrayExpr}}}{{if ${condition}}}{{$i}}{{break}}{{end}}{{end}}`;
+    }
+    return null;
+  }
+  renderEverySomeTemplateBlock(expr, renderArray) {
+    const arrayExpr = renderArray(expr.object);
+    const condition = this.renderFilterExpr(expr.predicate, expr.param);
+    if (condition.includes("[UNSUPPORTED"))
+      return null;
+    if (expr.method === "every") {
+      const negated = this.negateGoCondition(condition);
+      return `{{$bf_result := true}}{{range ${arrayExpr}}}{{if ${negated}}}{{$bf_result = false}}{{break}}{{end}}{{end}}{{$bf_result}}`;
+    }
+    if (expr.method === "some") {
+      return `{{$bf_result := false}}{{range ${arrayExpr}}}{{if ${condition}}}{{$bf_result = true}}{{break}}{{end}}{{end}}{{$bf_result}}`;
+    }
+    return null;
+  }
+  negateGoCondition(condition) {
+    const goFuncPattern = /^(eq|ne|gt|lt|ge|le|and|or|not|bf_)\b/;
+    if (goFuncPattern.test(condition)) {
+      return `not (${condition})`;
+    }
+    return `not ${condition}`;
+  }
+  renderFilterLengthExpr(filterExpr, renderArray) {
+    if (filterExpr.method !== "filter") {
+      return null;
+    }
+    const { field, negated } = this.extractFieldPredicate(filterExpr.predicate, filterExpr.param);
+    if (!field) {
+      return null;
+    }
+    const arrayExpr = renderArray(filterExpr.object);
+    const value = negated ? "false" : "true";
+    return `len (bf_filter ${arrayExpr} "${field}" ${value})`;
+  }
+  renderPredicateCondition(pred, param) {
+    return this.renderFilterExpr(pred, param);
+  }
+  needsParens(expr) {
+    return expr.kind === "logical" || expr.kind === "unary" || expr.kind === "conditional";
+  }
+  renderBlockBodyCondition(statements, param) {
+    const localVarMap = new Map;
+    const paths = this.collectReturnPaths(statements, [], localVarMap, param);
+    if (paths.length === 0) {
+      return "true";
+    }
+    if (paths.length === 1) {
+      const path = paths[0];
+      return this.buildSinglePathCondition(path, param, localVarMap);
+    }
+    return this.buildOrCondition(paths, param, localVarMap);
+  }
+  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 thenConditions = [...currentConditions, stmt.condition];
+        const thenPaths = this.collectReturnPaths(stmt.consequent, thenConditions, localVarMap, param);
+        paths.push(...thenPaths);
+        if (stmt.alternate) {
+          const negatedCondition = { kind: "unary", op: "!", argument: stmt.condition };
+          const elseConditions = [...currentConditions, negatedCondition];
+          const elsePaths = this.collectReturnPaths(stmt.alternate, elseConditions, localVarMap, param);
+          paths.push(...elsePaths);
+        } else {
+          const negatedCondition = { kind: "unary", op: "!", argument: stmt.condition };
+          currentConditions.push(negatedCondition);
+        }
+      }
+    }
+    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 "true";
+        }
+        return this.renderConditionsAnd(path.conditions, param, localVarMap);
+      } else {
+        return "false";
+      }
+    }
+    if (path.conditions.length === 0) {
+      return this.renderFilterExpr(path.result, param, localVarMap);
+    }
+    const condPart = this.renderConditionsAnd(path.conditions, param, localVarMap);
+    const resultPart = this.renderFilterExpr(path.result, param, localVarMap);
+    return `and (${condPart}) (${resultPart})`;
+  }
+  buildOrCondition(paths, param, localVarMap) {
+    const parts = [];
+    for (const path of paths) {
+      if (path.result.kind === "literal" && path.result.literalType === "boolean" && path.result.value === false) {
+        continue;
+      }
+      const pathCond = this.buildSinglePathCondition(path, param, localVarMap);
+      if (pathCond !== "false") {
+        parts.push(pathCond);
+      }
+    }
+    if (parts.length === 0) {
+      return "false";
+    }
+    if (parts.length === 1) {
+      return parts[0];
+    }
+    return `or ${parts.map((p) => `(${p})`).join(" ")}`;
+  }
+  renderConditionsAnd(conditions, param, localVarMap) {
+    if (conditions.length === 0) {
+      return "true";
+    }
+    if (conditions.length === 1) {
+      return this.renderFilterExpr(conditions[0], param, localVarMap);
+    }
+    const parts = conditions.map((c) => this.renderFilterExpr(c, param, localVarMap));
+    let result = parts[parts.length - 1];
+    for (let i = parts.length - 2;i >= 0; i--) {
+      result = `and (${parts[i]}) (${result})`;
+    }
+    return result;
+  }
+  renderFilterExpr(expr, param, localVarMap = new Map) {
+    if (this.filterExprDepth === 0)
+      this.filterExprUnsupported = false;
+    this.filterExprDepth++;
+    try {
+      return this.renderFilterExprNode(expr, param, localVarMap);
+    } finally {
+      this.filterExprDepth--;
+    }
+  }
+  renderFilterExprNode(expr, param, localVarMap) {
+    switch (expr.kind) {
+      case "identifier": {
+        if (expr.name === param) {
+          return ".";
+        }
+        const signal = localVarMap.get(expr.name);
+        if (signal) {
+          return `$.${this.capitalizeFieldName(signal)}`;
+        }
+        return `.${this.capitalizeFieldName(expr.name)}`;
+      }
+      case "literal":
+        if (expr.literalType === "string") {
+          return `"${expr.value}"`;
+        }
+        if (expr.literalType === "null") {
+          return '""';
+        }
+        return String(expr.value);
+      case "member": {
+        if (expr.object.kind === "identifier" && expr.object.name === param) {
+          return `.${this.capitalizeFieldName(expr.property)}`;
+        }
+        if (expr.property === "length" && expr.object.kind === "higher-order" && expr.object.method === "filter") {
+          const lenExpr = this.renderFilterLengthExpr(expr.object, (e) => this.renderFilterExpr(e, param, localVarMap));
+          if (lenExpr)
+            return `(${lenExpr})`;
+        }
+        const obj = this.renderFilterExpr(expr.object, param, localVarMap);
+        if (this.filterExprUnsupported)
+          return "false";
+        return `${obj}.${this.capitalizeFieldName(expr.property)}`;
+      }
+      case "call": {
+        if (expr.callee.kind === "member" && expr.callee.object.kind === "identifier" && expr.callee.object.name === param) {
+          return `.${this.capitalizeFieldName(expr.callee.property)}`;
+        }
+        if (expr.callee.kind === "identifier" && expr.args.length === 0) {
+          return `$.${this.capitalizeFieldName(expr.callee.name)}`;
+        }
+        const result = this.renderFilterExpr(expr.callee, param, localVarMap);
+        if (this.filterExprUnsupported)
+          return "false";
+        return result;
+      }
+      case "unary": {
+        const arg = this.renderFilterExpr(expr.argument, param, localVarMap);
+        if (this.filterExprUnsupported)
+          return "false";
+        if (expr.op === "!") {
+          const needsParens = this.isGoFunctionCall(expr.argument);
+          return needsParens ? `not (${arg})` : `not ${arg}`;
+        }
+        if (expr.op === "-") {
+          return `bf_neg ${arg}`;
+        }
+        return arg;
+      }
+      case "binary": {
+        const left = this.renderFilterExpr(expr.left, param, localVarMap);
+        if (this.filterExprUnsupported)
+          return "false";
+        const right = this.renderFilterExpr(expr.right, param, localVarMap);
+        if (this.filterExprUnsupported)
+          return "false";
+        switch (expr.op) {
+          case "===":
+          case "==":
+            return `eq ${left} ${right}`;
+          case "!==":
+          case "!=":
+            return `ne ${left} ${right}`;
+          case ">":
+            return `gt ${left} ${right}`;
+          case "<":
+            return `lt ${left} ${right}`;
+          case ">=":
+            return `ge ${left} ${right}`;
+          case "<=":
+            return `le ${left} ${right}`;
+          case "+":
+            return `bf_add ${left} ${right}`;
+          case "-":
+            return `bf_sub ${left} ${right}`;
+          case "*":
+            return `bf_mul ${left} ${right}`;
+          case "/":
+            return `bf_div ${left} ${right}`;
+          default:
+            return `${left} ${expr.op} ${right}`;
+        }
+      }
+      case "logical": {
+        const left = this.renderFilterExpr(expr.left, param, localVarMap);
+        if (this.filterExprUnsupported)
+          return "false";
+        const right = this.renderFilterExpr(expr.right, param, localVarMap);
+        if (this.filterExprUnsupported)
+          return "false";
+        if (expr.op === "&&") {
+          return `and (${left}) (${right})`;
+        }
+        return `or (${left}) (${right})`;
+      }
+      default: {
+        this.filterExprUnsupported = true;
+        this.errors.push({
+          code: "BF101",
+          severity: "error",
+          message: `Filter predicate contains an expression that cannot be lowered to a Go template action: ${exprToString(expr)}`,
+          loc: this.makeLoc(),
+          suggestion: {
+            message: "Options:\n1. Use /* @client */ for client-side evaluation\n2. Rewrite the predicate to avoid nested higher-order methods (`.filter()` / `.map()` / etc. inside the predicate body)"
+          }
+        });
+        return "false";
+      }
+    }
+  }
+  isGoFunctionCall(expr) {
+    switch (expr.kind) {
+      case "binary":
+        return ["===", "==", "!==", "!=", ">", "<", ">=", "<="].includes(expr.op);
+      case "logical":
+        return true;
+      case "unary":
+        return true;
+      case "member":
+        return expr.property === "length";
+      default:
+        return false;
+    }
+  }
+  renderConditionalBranch(expr) {
+    if (expr.kind === "literal" && expr.literalType === "string") {
+      return String(expr.value);
+    }
+    if (expr.kind === "conditional") {
+      const test = this.renderParsedExpr(expr.test);
+      const consequent = this.renderConditionalBranch(expr.consequent);
+      const alternate = this.renderConditionalBranch(expr.alternate);
+      return `{{if ${test}}}${consequent}{{else}}${alternate}{{end}}`;
+    }
+    return `{{${this.renderParsedExpr(expr)}}}`;
+  }
+  needsParensInGoTemplate(expr) {
+    switch (expr.kind) {
+      case "member":
+        return expr.property === "length";
+      case "binary":
+        return ["+", "-", "*", "/", "%"].includes(expr.op);
+      case "unary":
+        return expr.op === "-";
+      default:
+        return false;
+    }
+  }
+  convertExpressionToGo(jsExpr) {
+    const trimmed = jsExpr.trim();
+    if (trimmed === "null" || trimmed === "undefined") {
+      return '""';
+    }
+    const parsed = parseExpression(trimmed);
+    const support = isSupported(parsed);
+    if (!support.supported) {
+      this.errors.push({
+        code: "BF101",
+        severity: "error",
+        message: `Expression not supported: ${trimmed}`,
+        loc: this.makeLoc(),
+        suggestion: {
+          message: support.reason ? `${support.reason}
+
+Options:
+1. Use @client directive for client-side evaluation
+2. Pre-compute the value in Go code` : `Options:
+1. Use @client directive for client-side evaluation
+2. Pre-compute the value in Go code`
+        }
+      });
+      return `""`;
+    }
+    return this.renderParsedExpr(parsed);
+  }
+  makeLoc() {
+    return {
+      file: this.componentName + ".tsx",
+      start: { line: 1, column: 0 },
+      end: { line: 1, column: 0 }
+    };
+  }
+  renderIfStatement(ifStmt, ctx) {
+    const { condition: goCondition, preamble } = this.convertConditionToGo(ifStmt.condition);
+    const consequent = this.renderNode(ifStmt.consequent, ctx);
+    let result = `${preamble}{{if ${goCondition}}}${consequent}`;
+    if (ifStmt.alternate) {
+      if (ifStmt.alternate.type === "if-statement") {
+        const altIfStmt = ifStmt.alternate;
+        const { condition: altCondition, preamble: altPreamble } = this.convertConditionToGo(altIfStmt.condition);
+        if (altPreamble) {
+          this.errors.push({
+            code: "BF102",
+            severity: "error",
+            message: `Complex predicate in else-if is not supported: ${altIfStmt.condition}`,
+            loc: this.makeLoc(),
+            suggestion: {
+              message: `Options:
+1. Use @client directive for client-side evaluation
+2. Pre-compute the value in Go code`
+            }
+          });
+        }
+        const altConsequent = this.renderNode(altIfStmt.consequent, ctx);
+        result += `{{else if ${altCondition}}}${altConsequent}`;
+        if (altIfStmt.alternate) {
+          const altElse = this.renderNode(altIfStmt.alternate, ctx);
+          result += `{{else}}${altElse}`;
+        }
+      } else {
+        const alternate = this.renderNode(ifStmt.alternate, ctx);
+        result += `{{else}}${alternate}`;
+      }
+    }
+    result += "{{end}}";
+    return result;
+  }
+  renderConditional(cond) {
+    if (cond.clientOnly) {
+      return this.renderClientOnlyConditional(cond);
+    }
+    const { condition: goCondition, preamble } = this.convertConditionToGo(cond.condition);
+    const whenTrue = this.renderNode(cond.whenTrue);
+    if (cond.slotId) {
+      const whenTrueWrapped = this.wrapWithCondMarker(whenTrue, cond.slotId);
+      let result2 = `${preamble}{{if ${goCondition}}}${whenTrueWrapped}`;
+      if (cond.whenFalse) {
+        if (cond.whenFalse.type === "expression") {
+          const exprNode = cond.whenFalse;
+          if (exprNode.expr === "null" || exprNode.expr === "undefined") {
+            const emptyMarkers = `{{bfComment "cond-start:${cond.slotId}"}}{{bfComment "cond-end:${cond.slotId}"}}`;
+            result2 += `{{else}}${emptyMarkers}`;
+          } else {
+            const whenFalse = this.renderNode(cond.whenFalse);
+            const whenFalseWrapped = this.wrapWithCondMarker(whenFalse, cond.slotId);
+            result2 += `{{else}}${whenFalseWrapped}`;
+          }
+        } else {
+          const whenFalse = this.renderNode(cond.whenFalse);
+          const whenFalseWrapped = this.wrapWithCondMarker(whenFalse, cond.slotId);
+          result2 += `{{else}}${whenFalseWrapped}`;
+        }
+      }
+      result2 += "{{end}}";
+      return result2;
+    }
+    let result = `${preamble}{{if ${goCondition}}}${whenTrue}`;
+    if (cond.whenFalse && cond.whenFalse.type !== "expression") {
+      const whenFalse = this.renderNode(cond.whenFalse);
+      if (whenFalse && whenFalse !== '{{""}}') {
+        result += `{{else}}${whenFalse}`;
+      }
+    } else if (cond.whenFalse && cond.whenFalse.type === "expression") {
+      const exprNode = cond.whenFalse;
+      if (exprNode.expr !== "null" && exprNode.expr !== "undefined") {
+        const whenFalse = this.renderNode(cond.whenFalse);
+        if (whenFalse && whenFalse !== '{{""}}') {
+          result += `{{else}}${whenFalse}`;
+        }
+      }
+    }
+    result += "{{end}}";
+    return result;
+  }
+  convertConditionToGo(jsCondition) {
+    const trimmed = jsCondition.trim();
+    const parsed = parseExpression(trimmed);
+    const support = isSupported(parsed);
+    if (!support.supported) {
+      this.errors.push({
+        code: "BF102",
+        severity: "error",
+        message: `Condition not supported: ${trimmed}`,
+        loc: this.makeLoc(),
+        suggestion: {
+          message: support.reason ? `${support.reason}
+
+Options:
+1. Use @client directive for client-side evaluation
+2. Pre-compute the value in Go code` : "Expression contains unsupported syntax"
+        }
+      });
+      return { condition: `false`, preamble: "" };
+    }
+    const rendered = this.renderConditionExpr(parsed);
+    if (rendered.startsWith("{{")) {
+      const lastOpen = rendered.lastIndexOf("{{");
+      const lastClose = rendered.lastIndexOf("}}");
+      if (lastOpen >= 0 && lastClose > lastOpen) {
+        const preamble = rendered.substring(0, lastOpen);
+        const condition = rendered.substring(lastOpen + 2, lastClose);
+        return { condition, preamble };
+      }
+    }
+    return { condition: rendered, preamble: "" };
+  }
+  renderConditionExpr(expr) {
+    switch (expr.kind) {
+      case "identifier":
+        {
+          const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1];
+          if (currentLoopParam && expr.name === currentLoopParam) {
+            return ".";
+          }
+        }
+        return `.${this.capitalizeFieldName(expr.name)}`;
+      case "literal":
+        if (expr.literalType === "string") {
+          return `"${expr.value}"`;
+        }
+        if (expr.literalType === "null") {
+          return '""';
+        }
+        return String(expr.value);
+      case "call": {
+        if (expr.callee.kind === "identifier" && expr.args.length === 0) {
+          return `.${this.capitalizeFieldName(expr.callee.name)}`;
+        }
+        return this.renderParsedExpr(expr);
+      }
+      case "member": {
+        if (expr.property === "length" && expr.object.kind === "higher-order") {
+          const result = this.renderFilterLengthExpr(expr.object, (e) => this.renderConditionExpr(e));
+          if (result) {
+            return result;
+          }
+        }
+        if (expr.object.kind === "identifier" && this.propsObjectName && expr.object.name === this.propsObjectName) {
+          return `.${this.capitalizeFieldName(expr.property)}`;
+        }
+        {
+          const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1];
+          if (expr.object.kind === "identifier" && currentLoopParam && expr.object.name === currentLoopParam) {
+            return `.${this.capitalizeFieldName(expr.property)}`;
+          }
+        }
+        const obj = this.renderConditionExpr(expr.object);
+        if (expr.property === "length") {
+          return `len ${obj}`;
+        }
+        return `${obj}.${this.capitalizeFieldName(expr.property)}`;
+      }
+      case "binary": {
+        const leftNeedsParens = this.needsParensInGoTemplate(expr.left);
+        let left = this.renderConditionExpr(expr.left);
+        if (leftNeedsParens) {
+          left = `(${left})`;
+        }
+        const rightNeedsParens = this.needsParensInGoTemplate(expr.right);
+        let right = this.renderConditionExpr(expr.right);
+        if (rightNeedsParens) {
+          right = `(${right})`;
+        }
+        switch (expr.op) {
+          case "===":
+          case "==":
+            return `eq ${left} ${right}`;
+          case "!==":
+          case "!=":
+            return `ne ${left} ${right}`;
+          case ">":
+            return `gt ${left} ${right}`;
+          case "<":
+            return `lt ${left} ${right}`;
+          case ">=":
+            return `ge ${left} ${right}`;
+          case "<=":
+            return `le ${left} ${right}`;
+          case "+":
+            return `bf_add ${left} ${right}`;
+          case "-":
+            return `bf_sub ${left} ${right}`;
+          case "*":
+            return `bf_mul ${left} ${right}`;
+          case "/":
+            return `bf_div ${left} ${right}`;
+          default:
+            return `${left} ${expr.op} ${right}`;
+        }
+      }
+      case "unary": {
+        const arg = this.renderConditionExpr(expr.argument);
+        if (expr.op === "!") {
+          return `not ${arg}`;
+        }
+        if (expr.op === "-") {
+          return `bf_neg ${arg}`;
+        }
+        return arg;
+      }
+      case "logical": {
+        const left = this.renderConditionExpr(expr.left);
+        const right = this.renderConditionExpr(expr.right);
+        const wrapLeft = this.needsParens(expr.left) ? `(${left})` : left;
+        const wrapRight = this.needsParens(expr.right) ? `(${right})` : right;
+        if (expr.op === "&&") {
+          return `and ${wrapLeft} ${wrapRight}`;
+        }
+        return `or ${wrapLeft} ${wrapRight}`;
+      }
+      case "conditional": {
+        const test = this.renderConditionExpr(expr.test);
+        return test;
+      }
+      case "template-literal":
+        return this.renderParsedExpr(expr);
+      case "arrow-fn":
+        return "[ARROW-FN]";
+      case "higher-order":
+        return this.renderParsedExpr(expr);
+      case "array-literal":
+        return this.renderParsedExpr(expr);
+      case "array-method":
+        return this.renderParsedExpr(expr);
+      case "unsupported":
+        return expr.raw;
+    }
+  }
+  renderLoop(loop) {
+    if (loop.clientOnly) {
+      return `{{bfComment "loop:${loop.markerId}"}}{{bfComment "/loop:${loop.markerId}"}}`;
+    }
+    if (loop.paramBindings && loop.paramBindings.length > 0) {
+      this.errors.push({
+        code: "BF104",
+        severity: "error",
+        message: `Loop callback uses an array/object destructure pattern (\`${loop.param}\`) that the Go template adapter cannot lower — Go's \`{{range}}\` only supports single-name bindings.`,
+        loc: loop.loc ?? this.makeLoc(),
+        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.`
+        }
+      });
+    }
+    let goArray = this.convertExpressionToGo(loop.array);
+    const param = loop.param;
+    const index = loop.index || "_";
+    const childComponent = this.findChildComponent(loop.children);
+    if (childComponent) {
+      goArray = `.${childComponent.name}s`;
+    }
+    this.inLoop = true;
+    this.loopParamStack.push(param);
+    const children = this.renderChildren(loop.children);
+    this.loopParamStack.pop();
+    this.inLoop = false;
+    if (loop.sortComparator) {
+      goArray = `(${emitBfSort(goArray, loop.sortComparator)})`;
+    }
+    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.renderPredicateCondition(loop.filterPredicate.predicate, loop.filterPredicate.param);
+      } else {
+        filterCond = "true";
+      }
+      const itemMarker2 = loop.bodyIsMultiRoot ? `{{bfComment "bf-loop-i"}}` : "";
+      return `{{bfComment "loop:${loop.markerId}"}}{{range $${index}, $${param} := ${goArray}}}{{if ${filterCond}}}${itemMarker2}${children}{{end}}{{end}}{{bfComment "/loop:${loop.markerId}"}}`;
+    }
+    const itemMarker = loop.bodyIsMultiRoot ? `{{bfComment "bf-loop-i"}}` : "";
+    return `{{bfComment "loop:${loop.markerId}"}}{{range $${index}, $${param} := ${goArray}}}${itemMarker}${children}{{end}}{{bfComment "/loop:${loop.markerId}"}}`;
+  }
+  findChildComponent(nodes) {
+    for (const node of nodes) {
+      if (node.type === "component") {
+        return node;
+      }
+      if (node.type === "element" && node.children) {
+        const found = this.findChildComponent(node.children);
+        if (found)
+          return found;
+      }
+      if (node.type === "fragment" && node.children) {
+        const found = this.findChildComponent(node.children);
+        if (found)
+          return found;
+      }
+    }
+    return null;
+  }
+  renderComponent(comp, ctx) {
+    if (comp.name === "Portal") {
+      return this.renderPortalComponent(comp);
+    }
+    let templateCall;
+    if (this.inLoop) {
+      templateCall = `{{template "${comp.name}" .}}`;
+    } else if (comp.slotId) {
+      const suffix = slotIdToFieldSuffix(comp.slotId);
+      templateCall = `{{template "${comp.name}" .${comp.name}${suffix}}}`;
+    } else {
+      templateCall = `{{template "${comp.name}" .${comp.name}}}`;
+    }
+    if (ctx?.isRootOfClientComponent) {
+      return `{{bfScopeComment .}}${templateCall}`;
+    }
+    return templateCall;
+  }
+  renderPortalComponent(comp) {
+    const children = this.renderChildren(comp.children);
+    const escapedContent = children.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n");
+    if (children.includes("{{")) {
+      return `{{.Portals.Add .ScopeID (bfPortalHTML . "${escapedContent}")}}`;
+    }
+    return `{{.Portals.Add .ScopeID "${escapedContent}"}}`;
+  }
+  renderFragment(fragment) {
+    const children = this.renderChildren(fragment.children);
+    if (fragment.needsScopeComment) {
+      return `{{bfScopeComment .}}${children}`;
+    }
+    return children;
+  }
+  renderSlot(slot) {
+    const slotName = slot.name === "default" ? "children" : slot.name;
+    return `{{block "${slotName}" .}}{{end}}`;
+  }
+  renderAsync(node) {
+    const fallback = this.renderNode(node.fallback);
+    const children = this.renderChildren(node.children);
+    return `{{bfAsyncBoundary "${node.id}" "${this.escapeGoString(fallback)}"}}
+${children}`;
+  }
+  escapeGoString(s) {
+    return s.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+  }
+  elementAttrEmitter = {
+    emitLiteral: (value, name) => `${name}="${value.value}"`,
+    emitExpression: (value, name) => {
+      if (isBooleanAttr(name) || value.presenceOrUndefined) {
+        const { condition: goCond, preamble } = this.convertConditionToGo(value.expr);
+        return `${preamble}{{if ${goCond}}}${name}{{end}}`;
+      }
+      const parsed = parseExpression(value.expr.trim());
+      if (parsed.kind === "conditional" || parsed.kind === "template-literal") {
+        return `${name}="${this.renderParsedExpr(parsed)}"`;
+      }
+      return `${name}="{{${this.convertExpressionToGo(value.expr)}}}"`;
+    },
+    emitBooleanAttr: (_value, name) => name,
+    emitSpread: (value) => {
+      if (!value.slotId) {
+        this.errors.push({
+          code: "BF101",
+          severity: "error",
+          message: `JSX spread '{...${value.expr}}' on an intrinsic element has no Go template lowering (missing slot id)`,
+          loc: this.makeLoc(),
+          suggestion: {
+            message: "This usually means a closed-type rest-prop spread was unexpectedly routed through the bag path — file a bug with the source."
+          }
+        });
+        return "";
+      }
+      if (this.inLoop) {
+        const trimmed = value.expr.trim();
+        const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1];
+        if (currentLoopParam && trimmed === currentLoopParam) {
+          return `{{bf_spread_attrs .}}`;
+        }
+        const goExpr = this.convertExpressionToGo(value.expr);
+        return `{{bf_spread_attrs ${goExpr}}}`;
+      }
+      return `{{bf_spread_attrs .${value.slotId}}}`;
+    },
+    emitTemplate: (value, name) => `${name}="${this.renderTemplateLiteralParts(value.parts)}"`,
+    emitBooleanShorthand: () => "",
+    emitJsxChildren: () => ""
+  };
+  renderAttributes(element) {
+    const parts = [];
+    for (const attr of element.attrs) {
+      let attrName;
+      if (attr.name === "className")
+        attrName = "class";
+      else if (attr.name === "key")
+        attrName = "data-key";
+      else
+        attrName = attr.name;
+      const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, attrName);
+      if (lowered)
+        parts.push(lowered);
+    }
+    return parts.length > 0 ? " " + parts.join(" ") : "";
+  }
+  substituteJsInterpolations(s) {
+    let out = "";
+    let i = 0;
+    while (i < s.length) {
+      const open = s.indexOf("${", i);
+      if (open === -1) {
+        out += this.escapeAttrText(s.slice(i));
+        break;
+      }
+      out += this.escapeAttrText(s.slice(i, open));
+      const close = findInterpolationEnd(s, open + 2);
+      if (close === -1) {
+        out += this.escapeAttrText(s.slice(open));
+        break;
+      }
+      const inner = s.slice(open + 2, close).trim();
+      if (inner) {
+        out += `{{${this.convertExpressionToGo(inner)}}}`;
+      } else {
+        out += s.slice(open, close + 1);
+      }
+      i = close + 1;
+    }
+    return out;
+  }
+  escapeAttrText(s) {
+    return s.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  }
+  renderTemplateLiteralParts(parts) {
+    let output = "";
+    for (const part of parts) {
+      if (part.type === "string") {
+        output += this.substituteJsInterpolations(part.value);
+      } else if (part.type === "ternary") {
+        const { condition: goCond, preamble } = this.convertConditionToGo(part.condition);
+        output += `${preamble}{{if ${goCond}}}${part.whenTrue}{{else}}${part.whenFalse}{{end}}`;
+      } else if (part.type === "lookup") {
+        const keyExpr = this.convertExpressionToGo(part.key);
+        const caseEntries = Object.entries(part.cases);
+        if (caseEntries.length === 0)
+          continue;
+        const branches = caseEntries.map(([k, v], i) => {
+          const head = i === 0 ? "{{if" : "{{else if";
+          return `${head} eq ${keyExpr} ${JSON.stringify(k)}}}${v}`;
+        });
+        output += branches.join("") + "{{end}}";
+      }
+    }
+    return output;
+  }
+  renderScopeMarker(_instanceIdExpr) {
+    return `bf-s="{{bfScopeAttr .}}" {{bfHydrationAttrs .}} {{bfPropsAttr .}}`;
+  }
+  renderSlotMarker(slotId) {
+    return `bf="${slotId}"`;
+  }
+  renderCondMarker(condId) {
+    return `bf-c="${condId}"`;
+  }
+  wrapWithCondMarker(content, condId) {
+    if (content.startsWith("<")) {
+      const match = content.match(/^<(\w+)/);
+      if (match) {
+        const tag = match[1];
+        const trimmed = content.trim();
+        const isSingle = new RegExp(`</${tag}>\\s*$`).test(trimmed) || /^<\w+[^>]*\/>$/.test(trimmed);
+        if (isSingle) {
+          return content.replace(`<${match[1]}`, `<${match[1]} ${this.renderCondMarker(condId)}`);
+        }
+      }
+    }
+    return `{{bfComment "cond-start:${condId}"}}${content}{{bfComment "cond-end:${condId}"}}`;
+  }
+}
+var goTemplateAdapter = new GoTemplateAdapter;
+export {
+  goTemplateAdapter,
+  GoTemplateAdapter
+};