@barefootjs/go-template 0.14.0 → 0.15.1

package/dist/build.js

@@ -377,9 +377,12 @@ import {
   augmentInheritedPropAccesses,
   parseRecordIndexAccess,
   collectContextConsumers,
-  isLowerableObjectRestDestructure
+  isLowerableObjectRestDestructure,
+  collectModuleStringConsts as collectModuleStringConstsShared,
+  searchParamsLocalNames
 } from "@barefootjs/jsx";
 import { findInterpolationEnd } from "@barefootjs/jsx/scanner";
+import { BF_REGION } from "@barefootjs/shared";
 function wrapIfMultiToken(rendered) {
   if (rendered.startsWith("(") && rendered.endsWith(")"))
     return rendered;
@@ -467,13 +470,29 @@ function buildUnsupportedSuggestion(support) {
 
 ${GO_REMEDIATION_OPTIONS}`;
 }
+function wrapGoArg(arg) {
+  if (!/\s/.test(arg))
+    return arg;
+  if (arg.startsWith("(") && arg.endsWith(")"))
+    return arg;
+  return `(${arg})`;
+}
+function stringTolerantEqOperands(l, r) {
+  const isStrLit = (x) => /^"(?:[^"\\]|\\.)*"$/.test(x);
+  if (isStrLit(l) === isStrLit(r))
+    return [l, r];
+  const wrap = (x) => isStrLit(x) ? x : `(bf_string ${wrapGoArg(x)})`;
+  return [wrap(l), wrap(r)];
+}
 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]}` }
+  "JSON.stringify": { arity: 1, emit: (args) => `bf_json ${wrapGoArg(args[0])}` },
+  String: { arity: 1, emit: (args) => `bf_string ${wrapGoArg(args[0])}` },
+  Number: { arity: 1, emit: (args) => `bf_number ${wrapGoArg(args[0])}` },
+  "Math.floor": { arity: 1, emit: (args) => `bf_floor ${wrapGoArg(args[0])}` },
+  "Math.ceil": { arity: 1, emit: (args) => `bf_ceil ${wrapGoArg(args[0])}` },
+  "Math.round": { arity: 1, emit: (args) => `bf_round ${wrapGoArg(args[0])}` },
+  "Math.min": { arity: 2, emit: (args) => `bf_min ${wrapGoArg(args[0])} ${wrapGoArg(args[1])}` },
+  "Math.max": { arity: 2, emit: (args) => `bf_max ${wrapGoArg(args[0])} ${wrapGoArg(args[1])}` }
 };
 
 class GoTemplateAdapter extends BaseAdapter {
@@ -488,10 +507,12 @@ class GoTemplateAdapter extends BaseAdapter {
   componentName = "";
   options;
   inLoop = false;
+  pendingChildrenDefines = [];
   loopParamStack = [];
   loopVarRefCount = new Map;
   loopBindingStack = [];
   errors = [];
+  currentMemos = [];
   propsObjectName = null;
   restPropsName = null;
   templateVarCounter = 0;
@@ -499,6 +520,7 @@ class GoTemplateAdapter extends BaseAdapter {
   localTypeAliases = new Map;
   localStructFields = new Map;
   synthStructTypes = new Map;
+  currentTypeDefinitions = [];
   usesHtmlTemplate = false;
   rootScopeNodes = new Set;
   usesFmt = false;
@@ -506,6 +528,11 @@ class GoTemplateAdapter extends BaseAdapter {
   moduleStringConsts = new Map;
   localConstants = [];
   contextConsumers = [];
+  searchParamsLocals = new Set;
+  localHelperNames = new Set;
+  needsStringsImport = false;
+  referencedDerivedConsts = new Set;
+  memoBackedLoopSlice = new Map;
   childContextConsumers = new Map;
   nillablePropNames = new Set;
   constructor(options = {}) {
@@ -519,12 +546,18 @@ class GoTemplateAdapter extends BaseAdapter {
   generate(ir, options) {
     this.componentName = ir.metadata.componentName;
     this.errors = [];
+    this.referencedDerivedConsts = new Set;
     this.templateVarCounter = 0;
+    this.pendingChildrenDefines = [];
     this.propsObjectName = ir.metadata.propsObjectName;
     this.restPropsName = ir.metadata.restPropsName ?? null;
     this.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants);
     this.localConstants = ir.metadata.localConstants ?? [];
+    this.localHelperNames = new Set(this.localConstants.filter((c) => !c.isModule && c.containsArrow).map((c) => c.name));
+    this.currentMemos = ir.metadata.memos ?? [];
+    this.currentTypeDefinitions = ir.metadata.typeDefinitions ?? [];
     this.contextConsumers = collectContextConsumers(ir.metadata);
+    this.searchParamsLocals = searchParamsLocalNames(ir.metadata);
     augmentInheritedPropAccesses(ir);
     this.nillablePropNames = this.collectNillablePropNames(ir);
     if (!options?.siblingTemplatesRegistered) {
@@ -534,12 +567,22 @@ class GoTemplateAdapter extends BaseAdapter {
     const isRootComponent = ir.root.type === "component";
     const isIfStatement = ir.root.type === "if-statement";
     this.rootScopeNodes = collectRootScopeNodes(ir.root);
+    this.memoBackedLoopSlice = new Map;
+    for (const nested of this.findNestedComponents(ir.root)) {
+      const memoName = this.extractMemoNameFromLoopArray(nested.loopArray);
+      if (memoName)
+        this.memoBackedLoopSlice.set(memoName, `${nested.name}s`);
+    }
     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}"}}
+    let template = `{{define "${this.componentName}"}}
 ${scriptRegistrations}${templateBody}
 {{end}}
 `;
+    for (const d of this.pendingChildrenDefines) {
+      template += `{{define "${d.name}"}}${d.content}{{end}}
+`;
+    }
     const types = this.generateTypes(ir);
     if (this.errors.length > 0) {
       ir.errors.push(...this.errors);
@@ -776,10 +819,15 @@ ${scriptRegistrations}${templateBody}
     this.usesHtmlTemplate = false;
     this.usesFmt = false;
     this.propsObjectName = ir.metadata.propsObjectName;
+    this.restPropsName = ir.metadata.restPropsName ?? null;
     augmentInheritedPropAccesses(ir);
     this.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants);
     this.localConstants = ir.metadata.localConstants ?? [];
+    this.localHelperNames = new Set(this.localConstants.filter((c) => !c.isModule && c.containsArrow).map((c) => c.name));
+    this.currentMemos = ir.metadata.memos ?? [];
+    this.currentTypeDefinitions = ir.metadata.typeDefinitions ?? [];
     this.contextConsumers = collectContextConsumers(ir.metadata);
+    this.searchParamsLocals = searchParamsLocalNames(ir.metadata);
     const lines = [];
     const componentName = ir.metadata.componentName;
     this.localTypeNames = new Set;
@@ -832,11 +880,39 @@ ${goFields.join(`
       lines.push("");
     }
     const nestedComponents = this.findNestedComponents(ir.root);
+    for (const nested of nestedComponents) {
+      if (nested.loopItemType || !nested.loopArray)
+        continue;
+      const memoName = this.extractMemoNameFromLoopArray(nested.loopArray);
+      if (memoName) {
+        const memo = ir.metadata.memos.find((m) => m.name === memoName);
+        if (memo) {
+          const blockReturn = this.resolveBlockBodyMemoModuleConst(memo.computation, ir.metadata.signals);
+          if (blockReturn) {
+            const constant = (ir.metadata.localConstants ?? []).find((c) => c.name === blockReturn.constName && c.origin?.scope === "module");
+            if (constant?.type?.elementType) {
+              nested.loopItemType = constant.type.elementType;
+            }
+          }
+        }
+        continue;
+      }
+      const directConst = (ir.metadata.localConstants ?? []).find((c) => c.name === nested.loopArray && c.origin?.scope === "module");
+      if (directConst?.type?.elementType) {
+        nested.loopItemType = directConst.type.elementType;
+      }
+    }
+    for (const nested of nestedComponents) {
+      if (!nested.bodyChildren || nested.bodyChildren.length === 0)
+        continue;
+      this.generateLoopBodyWrapperStruct(lines, componentName, nested);
+    }
     const propTypeOverrides = this.buildPropTypeOverrides(ir);
     const spreadSlots = this.collectSpreadSlots(ir.root);
     this.generateInputStruct(lines, ir, componentName, nestedComponents, propTypeOverrides, spreadSlots);
+    this.needsStringsImport = false;
     this.generatePropsStruct(lines, ir, componentName, nestedComponents, propTypeOverrides, spreadSlots);
-    this.generateNewPropsFunction(lines, ir, componentName, nestedComponents, spreadSlots);
+    this.generateNewPropsFunction(lines, ir, componentName, nestedComponents, spreadSlots, propTypeOverrides);
     const header = [];
     header.push(`package ${this.options.packageName}`);
     header.push("");
@@ -846,6 +922,8 @@ ${goFields.join(`
     if (this.usesHtmlTemplate)
       header.push('\t"html/template"');
     header.push('\t"math/rand"');
+    if (this.needsStringsImport)
+      header.push('\t"strings"');
     header.push("");
     header.push('\tbf "github.com/barefootjs/runtime/bf"');
     header.push(")");
@@ -1016,6 +1094,20 @@ ${goFields.join(`
     }
     return nillable;
   }
+  usesSearchParams(ir) {
+    if (this.searchParamsLocals.size === 0)
+      return false;
+    const taken = new Set([
+      ...ir.metadata.propsParams.map((p) => this.capitalizeFieldName(p.name)),
+      ...ir.metadata.signals.map((s) => this.capitalizeFieldName(s.getter)),
+      ...ir.metadata.memos.map((m) => this.capitalizeFieldName(m.name)),
+      ...this.contextConsumers.map((c) => this.contextFieldName(c))
+    ]);
+    if (ir.metadata.restPropsName) {
+      taken.add(this.capitalizeFieldName(ir.metadata.restPropsName));
+    }
+    return !taken.has("SearchParams");
+  }
   generateInputStruct(lines, ir, componentName, nestedComponents, propTypeOverrides, spreadSlots) {
     const inputTypeName = `${componentName}Input`;
     lines.push(`// ${inputTypeName} is the user-facing input type.`);
@@ -1023,6 +1115,9 @@ ${goFields.join(`
     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");
+    if (this.usesSearchParams(ir)) {
+      lines.push("\tSearchParams bf.SearchParams // Optional: request query for searchParams()");
+    }
     const inputNested = nestedComponents.filter((n) => !n.isDynamic || n.isPropDerived);
     const nestedArrayFields = new Set(nestedComponents.map((n) => `${n.name}s`));
     for (const param of ir.metadata.propsParams) {
@@ -1067,6 +1162,9 @@ ${goFields.join(`
     lines.push('\tBfMount string `json:"-"`');
     lines.push('\tBfDataKey string `json:"-"`');
     lines.push('\tScripts *bf.ScriptCollector `json:"-"`');
+    if (this.usesSearchParams(ir)) {
+      lines.push('\tSearchParams bf.SearchParams `json:"-"`');
+    }
     const nestedArrayFields = new Set(nestedComponents.map((n) => `${n.name}s`));
     const propFieldNames = new Set;
     for (const param of ir.metadata.propsParams) {
@@ -1113,10 +1211,20 @@ ${goFields.join(`
     }
     for (const memo of ir.metadata.memos) {
       const fieldName = this.capitalizeFieldName(memo.name);
+      if (propFieldNames.has(fieldName))
+        continue;
       const jsonTag = this.toJsonTag(memo.name);
       const goType = this.inferMemoType(memo, ir.metadata.signals, propsParamMap);
       lines.push(`	${fieldName} ${goType} \`json:"${jsonTag}"\``);
     }
+    const takenForDerivedConsts = new Set([
+      ...ir.metadata.propsParams.map((p) => this.capitalizeFieldName(p.name)),
+      ...ir.metadata.signals.map((s) => this.capitalizeFieldName(s.getter)),
+      ...ir.metadata.memos.map((m) => this.capitalizeFieldName(m.name))
+    ]);
+    for (const f of this.computeDerivedConstFields(takenForDerivedConsts)) {
+      lines.push(`	${f.name} string \`json:"-"\``);
+    }
     const takenProps = new Set([
       ...ir.metadata.propsParams.map((p) => this.capitalizeFieldName(p.name)),
       ...ir.metadata.signals.map((s) => this.capitalizeFieldName(s.getter)),
@@ -1127,11 +1235,12 @@ ${goFields.join(`
       lines.push(`	${this.contextFieldName(c)} ${this.contextConsumerGoType(c)} \`json:"${jsonTag}"\``);
     }
     for (const nested of nestedComponents) {
+      const elemType = nested.bodyChildren?.length ? this.loopBodyWrapperName(componentName, nested) : `${nested.name}Props`;
       if (nested.isDynamic && !nested.isPropDerived) {
-        lines.push(`	${nested.name}s []${nested.name}Props \`json:"-"\``);
+        lines.push(`	${nested.name}s []${elemType} \`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}"\``);
+        lines.push(`	${nested.name}s []${elemType} \`json:"${jsonTag}"\``);
       }
     }
     const staticChildren = this.collectStaticChildInstances(ir.root);
@@ -1145,10 +1254,73 @@ ${goFields.join(`
     lines.push("}");
     lines.push("");
   }
-  generateNewPropsFunction(lines, ir, componentName, nestedComponents, spreadSlots) {
+  generateLoopBodyWrapperStruct(lines, parentComponentName, nested) {
+    const wrapperName = this.loopBodyWrapperName(parentComponentName, nested);
+    const datumFields = this.resolveLoopDatumFields(nested.loopItemType);
+    const bodyChildInstances = this.collectBodyChildInstances(nested.bodyChildren);
+    lines.push(`// ${wrapperName} wraps ${nested.name}Props with per-row loop datum`);
+    lines.push(`// fields and child component slots for the loop body children. (#1897)`);
+    lines.push(`type ${wrapperName} struct {`);
+    lines.push(`	${nested.name}Props`);
+    for (const f of datumFields) {
+      lines.push(`	${f.goName} ${f.goType} \`json:"-"\``);
+    }
+    for (const child of bodyChildInstances) {
+      lines.push(`	${child.fieldName} ${child.name}Props \`json:"-"\``);
+    }
+    lines.push("}");
+    lines.push("");
+  }
+  extractMemoNameFromLoopArray(loopArray) {
+    if (!loopArray)
+      return null;
+    const match = loopArray.match(/^(\w+)\(\)$/);
+    return match ? match[1] : null;
+  }
+  loopBodyWrapperName(parentName, nested) {
+    return `${parentName}${nested.name}L${nested.loopMarkerId ?? "0"}Ctx`;
+  }
+  resolveLoopDatumFields(itemType) {
+    if (!itemType)
+      return [];
+    const typeName = itemType.raw?.replace(/\[\]$/, "") ?? itemType.raw;
+    if (!typeName)
+      return [];
+    for (const td of this.currentTypeDefinitions) {
+      if (td.name === typeName) {
+        const fields = [];
+        for (const prop of td.properties ?? []) {
+          if (!GoTemplateAdapter.GO_IDENTIFIER.test(prop.name))
+            continue;
+          fields.push({
+            tsName: prop.name,
+            goName: this.capitalizeFieldName(prop.name),
+            goType: this.typeInfoToGo(prop.type)
+          });
+        }
+        if (fields.length > 0)
+          return fields;
+        break;
+      }
+    }
+    const structFields = this.localStructFields.get(typeName);
+    if (structFields) {
+      return Array.from(structFields, ([tsName, goName]) => ({ tsName, goName, goType: "interface{}" }));
+    }
+    return [];
+  }
+  collectBodyChildInstances(bodyChildren) {
+    const result = [];
+    for (const child of bodyChildren) {
+      this.collectStaticChildInstancesRecursive(child, result, false, new Map);
+    }
+    return result;
+  }
+  generateNewPropsFunction(lines, ir, componentName, nestedComponents, spreadSlots, propTypeOverrides) {
     const inputTypeName = `${componentName}Input`;
     const propsTypeName = `${componentName}Props`;
-    const signalDynamicNested = nestedComponents.filter((n) => n.isDynamic && !n.isPropDerived);
+    const dynamicWithBody = nestedComponents.filter((n) => n.isDynamic && !n.isPropDerived && n.bodyChildren && n.bodyChildren.length > 0);
+    const signalDynamicNested = nestedComponents.filter((n) => n.isDynamic && !n.isPropDerived && !(n.bodyChildren && n.bodyChildren.length > 0));
     lines.push(`// New${componentName}Props creates ${propsTypeName} from ${inputTypeName}.`);
     for (const nested of signalDynamicNested) {
       const arrayField = `${nested.name}s`;
@@ -1173,22 +1345,77 @@ ${goFields.join(`
     lines.push("\t}");
     lines.push("");
     const staticNested = nestedComponents.filter((n) => !n.isDynamic || n.isPropDerived);
-    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}"`);
-        const keyField = loopKeyToGoFieldPath(nested.loopKey, nested.loopParam);
-        if (keyField) {
-          lines.push(`		${varName}[i].BfDataKey = fmt.Sprint(${keyField})`);
-          this.usesFmt = true;
+    const emittedWrapperVars = new Set;
+    const staticWithBody = staticNested.filter((n) => n.bodyChildren && n.bodyChildren.length > 0);
+    const staticWithoutBody = staticNested.filter((n) => !n.bodyChildren || n.bodyChildren.length === 0);
+    for (const nested of staticWithoutBody) {
+      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}"`);
+      const keyField = loopKeyToGoFieldPath(nested.loopKey, nested.loopParam);
+      if (keyField) {
+        lines.push(`		${varName}[i].BfDataKey = fmt.Sprint(${keyField})`);
+        this.usesFmt = true;
+      }
+      lines.push("\t}");
+      lines.push("");
+    }
+    for (const nested of staticWithBody) {
+      const loopArray = nested.loopArray;
+      const moduleConst = loopArray ? (ir.metadata.localConstants ?? []).find((c) => c.name === loopArray && c.origin?.scope === "module" && c.value && c.type) : null;
+      const bakedValue = moduleConst?.type ? this.convertInitialValue(moduleConst.value, moduleConst.type, ir.metadata.propsParams) : null;
+      if (!bakedValue || bakedValue === "nil" || bakedValue === "0")
+        continue;
+      const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`;
+      const wrapperType = this.loopBodyWrapperName(componentName, nested);
+      const datumFields = this.resolveLoopDatumFields(nested.loopItemType);
+      const bodyChildInstances = this.collectBodyChildInstances(nested.bodyChildren);
+      for (const child of bodyChildInstances) {
+        const childVar = `child_${child.fieldName}`;
+        lines.push(`	${childVar} := 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) {
+          if (prop.value.kind === "literal") {
+            lines.push(`		${this.capitalizeFieldName(prop.name)}: ${this.goLiteral(prop.value.value)},`);
+          } else if (prop.value.kind === "boolean-shorthand" || prop.value.kind === "boolean-attr") {
+            lines.push(`		${this.capitalizeFieldName(prop.name)}: true,`);
+          }
         }
-        lines.push("\t}");
-        lines.push("");
+        lines.push(`	})`);
       }
+      if (bodyChildInstances.length > 0)
+        lines.push("");
+      const dataVar = `${varName}Data`;
+      lines.push(`	${dataVar} := ${bakedValue}`);
+      lines.push(`	${varName} := make([]${wrapperType}, len(${dataVar}))`);
+      lines.push(`	for i, item := range ${dataVar} {`);
+      lines.push(`		${varName}[i] = ${wrapperType}{`);
+      lines.push(`			${nested.name}Props: New${nested.name}Props(${nested.name}Input{`);
+      lines.push(`				BfParent: scopeID,`);
+      lines.push(`				BfMount: "${nested.slotId}",`);
+      lines.push(`			}),`);
+      for (const f of datumFields) {
+        lines.push(`			${f.goName}: item.${f.goName},`);
+      }
+      for (const child of bodyChildInstances) {
+        lines.push(`			${child.fieldName}: child_${child.fieldName},`);
+      }
+      lines.push(`		}`);
+      lines.push(`		${varName}[i].BfParent = scopeID`);
+      lines.push(`		${varName}[i].BfMount = "${nested.slotId}"`);
+      const keyField = loopKeyToGoFieldPath(nested.loopKey, nested.loopParam);
+      if (keyField) {
+        lines.push(`		${varName}[i].BfDataKey = fmt.Sprint(${keyField})`);
+        this.usesFmt = true;
+      }
+      lines.push("\t}");
+      lines.push("");
+      emittedWrapperVars.add(varName);
     }
     const propFallbackVars = this.collectPropFallbackVars(ir);
     for (const [, info] of propFallbackVars) {
@@ -1199,11 +1426,87 @@ ${goFields.join(`
     }
     if (propFallbackVars.size > 0)
       lines.push("");
+    const propsParamMap = new Map(ir.metadata.propsParams.map((p) => [p.name, p]));
+    for (const nested of dynamicWithBody) {
+      const memoName = this.extractMemoNameFromLoopArray(nested.loopArray);
+      if (!memoName)
+        continue;
+      const memo = ir.metadata.memos.find((m) => m.name === memoName);
+      if (!memo)
+        continue;
+      const goType = this.inferMemoType(memo, ir.metadata.signals, propsParamMap);
+      const bakedValue = this.computeMemoInitialValue(memo, ir.metadata.signals, ir.metadata.propsParams, propFallbackVars, goType);
+      if (bakedValue === "nil" || bakedValue === "0")
+        continue;
+      const wrapperType = this.loopBodyWrapperName(componentName, nested);
+      const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`;
+      const datumFields = this.resolveLoopDatumFields(nested.loopItemType);
+      const bodyChildInstances = this.collectBodyChildInstances(nested.bodyChildren);
+      for (const child of bodyChildInstances) {
+        const childVar = `child_${child.fieldName}`;
+        lines.push(`	${childVar} := 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) {
+          if (prop.value.kind === "literal") {
+            lines.push(`		${this.capitalizeFieldName(prop.name)}: ${this.goLiteral(prop.value.value)},`);
+          } else if (prop.value.kind === "boolean-shorthand" || prop.value.kind === "boolean-attr") {
+            lines.push(`		${this.capitalizeFieldName(prop.name)}: true,`);
+          }
+        }
+        lines.push(`	})`);
+      }
+      if (bodyChildInstances.length > 0)
+        lines.push("");
+      lines.push(`	bakedData := ${bakedValue}`);
+      lines.push(`	${varName} := make([]${wrapperType}, len(bakedData))`);
+      lines.push(`	for i, item := range bakedData {`);
+      lines.push(`		${varName}[i] = ${wrapperType}{`);
+      lines.push(`			${nested.name}Props: New${nested.name}Props(${nested.name}Input{`);
+      lines.push(`				BfParent: scopeID,`);
+      lines.push(`				BfMount: "${nested.slotId}",`);
+      lines.push(`			}),`);
+      for (const f of datumFields) {
+        lines.push(`			${f.goName}: item.${f.goName},`);
+      }
+      for (const child of bodyChildInstances) {
+        lines.push(`			${child.fieldName}: child_${child.fieldName},`);
+      }
+      lines.push(`		}`);
+      const keyField = loopKeyToGoFieldPath(nested.loopKey, nested.loopParam);
+      if (keyField) {
+        lines.push(`		${varName}[i].BfDataKey = fmt.Sprint(${keyField})`);
+        this.usesFmt = true;
+      }
+      lines.push(`	}`);
+      lines.push("");
+      emittedWrapperVars.add(varName);
+    }
     lines.push(`	return ${propsTypeName}{`);
     lines.push("\t\tScopeID: scopeID,");
     lines.push("\t\tBfParent: in.BfParent,");
     lines.push("\t\tBfMount: in.BfMount,");
+    if (this.usesSearchParams(ir)) {
+      lines.push("\t\tSearchParams: in.SearchParams,");
+    }
     const nestedArrayFields = new Set(nestedComponents.map((n) => `${n.name}s`));
+    const memoFallbacks = new Map;
+    for (const memo of ir.metadata.memos) {
+      const stripped = memo.computation.replace(/^\(\)\s*=>\s*/, "");
+      const m = this.extractPropFallback(stripped);
+      if (!m)
+        continue;
+      if (this.capitalizeFieldName(m.propName) !== this.capitalizeFieldName(memo.name))
+        continue;
+      const param = ir.metadata.propsParams.find((p) => this.capitalizeFieldName(p.name) === this.capitalizeFieldName(memo.name));
+      if (!param)
+        continue;
+      const goType = this.resolvePropGoType(param, propTypeOverrides);
+      if (goType !== "string" && goType !== "interface{}")
+        continue;
+      memoFallbacks.set(this.capitalizeFieldName(memo.name), { goFallback: m.goFallback, goType });
+    }
     const propFieldNames = new Set;
     for (const param of ir.metadata.propsParams) {
       const fieldName = this.capitalizeFieldName(param.name);
@@ -1213,9 +1516,14 @@ ${goFields.join(`
       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)},`);
+        const paramDefault = this.goPropDefault(param.defaultValue);
+        const memoFold = memoFallbacks.get(fieldName);
+        if (paramDefault !== null) {
+          lines.push(`		${fieldName}: ${this.applyGoFallback(`in.${fieldName}`, paramDefault)},`);
+        } else if (memoFold !== undefined && memoFold.goType === "string") {
+          lines.push(`		${fieldName}: ${this.applyGoFallback(`in.${fieldName}`, memoFold.goFallback)},`);
+        } else if (memoFold !== undefined) {
+          lines.push(`		${fieldName}: func() interface{} { v := interface{}(in.${fieldName}); if v == nil || v == "" { return ${memoFold.goFallback} }; return v }(),`);
         } else {
           lines.push(`		${fieldName}: in.${fieldName},`);
         }
@@ -1236,17 +1544,33 @@ ${goFields.join(`
         lines.push(`		${fieldName}: ${initialValue},`);
       }
     }
-    for (const nested of staticNested) {
+    for (const nested of staticWithoutBody) {
+      const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`;
+      lines.push(`		${nested.name}s: ${varName},`);
+    }
+    for (const nested of [...staticWithBody, ...dynamicWithBody]) {
       const varName = `${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`;
+      if (!emittedWrapperVars.has(varName))
+        continue;
       lines.push(`		${nested.name}s: ${varName},`);
     }
     const memoPropsParamMap = new Map(ir.metadata.propsParams.map((p) => [p.name, p]));
     for (const memo of ir.metadata.memos) {
       const fieldName = this.capitalizeFieldName(memo.name);
+      if (propFieldNames.has(fieldName))
+        continue;
       const goType = this.inferMemoType(memo, ir.metadata.signals, memoPropsParamMap);
       const memoValue = this.computeMemoInitialValue(memo, ir.metadata.signals, ir.metadata.propsParams, propFallbackVars, goType);
       lines.push(`		${fieldName}: ${memoValue},`);
     }
+    const takenDerivedInit = new Set([
+      ...ir.metadata.propsParams.map((p) => this.capitalizeFieldName(p.name)),
+      ...ir.metadata.signals.map((s) => this.capitalizeFieldName(s.getter)),
+      ...ir.metadata.memos.map((m) => this.capitalizeFieldName(m.name))
+    ]);
+    for (const f of this.computeDerivedConstFields(takenDerivedInit)) {
+      lines.push(`		${f.name}: ${f.init},`);
+    }
     const takenInit = new Set([
       ...ir.metadata.propsParams.map((p) => this.capitalizeFieldName(p.name)),
       ...ir.metadata.signals.map((s) => this.capitalizeFieldName(s.getter)),
@@ -1279,6 +1603,8 @@ ${goFields.join(`
           restBagEntries.push(`${JSON.stringify(jsxName)}: ${goValue}`);
           return;
         }
+        if (jsxName.includes("-"))
+          return;
         lines.push(`			${this.capitalizeFieldName(jsxName)}: ${goValue},`);
       };
       for (const prop of child.props) {
@@ -1360,12 +1686,17 @@ ${goFields.join(`
       const loop = node;
       if (loop.childComponent) {
         if (!result.some((c) => c.name === loop.childComponent.name)) {
+          const hasBodyChildren = loop.childComponent.children.length > 0;
           result.push({
             ...loop.childComponent,
             isDynamic: !loop.isStaticArray,
             isPropDerived: !!loop.isPropDerivedArray,
             loopKey: loop.key ?? undefined,
-            loopParam: loop.param ?? undefined
+            loopParam: loop.param ?? undefined,
+            bodyChildren: hasBodyChildren ? loop.childComponent.children : undefined,
+            loopArray: loop.array,
+            loopMarkerId: loop.markerId,
+            loopItemType: loop.itemType
           });
         }
       }
@@ -1388,6 +1719,17 @@ ${goFields.join(`
       if (cond.whenFalse) {
         this.collectNestedComponents(cond.whenFalse, result);
       }
+    } else if (node.type === "if-statement") {
+      const stmt = node;
+      this.collectNestedComponents(stmt.consequent, result);
+      if (stmt.alternate) {
+        this.collectNestedComponents(stmt.alternate, result);
+      }
+    } else if (node.type === "component") {
+      const comp = node;
+      for (const child of comp.children) {
+        this.collectNestedComponents(child, result);
+      }
     }
   }
   collectStaticChildInstances(node) {
@@ -1459,6 +1801,9 @@ ${goFields.join(`
           childrenScopedHtmlExpr: this.extractScopedHtmlChildren(effectiveChildren),
           contextBindings: providerCtx.size > 0 ? providerCtx : undefined
         });
+        for (const child of effectiveChildren) {
+          this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx);
+        }
       }
       if (comp.name === "Portal" && comp.children) {
         for (const child of comp.children) {
@@ -1486,6 +1831,12 @@ ${goFields.join(`
       if (cond.whenFalse) {
         this.collectStaticChildInstancesRecursive(cond.whenFalse, result, inLoop, providerCtx);
       }
+    } else if (node.type === "if-statement") {
+      const stmt = node;
+      this.collectStaticChildInstancesRecursive(stmt.consequent, result, inLoop, providerCtx);
+      if (stmt.alternate) {
+        this.collectStaticChildInstancesRecursive(stmt.alternate, result, inLoop, providerCtx);
+      }
     } else if (node.type === "provider") {
       const p = node;
       const childCtx = this.extendProviderContext(providerCtx, p);
@@ -1993,8 +2344,8 @@ ${goFields.join(`
         }
         const lines = [];
         lines.push("func() string {");
-        lines.push(`			k, _ := in.${fieldName}.(string)`);
-        lines.push("\t\t\tswitch k {");
+        this.usesFmt = true;
+        lines.push(`			switch fmt.Sprint(in.${fieldName}) {`);
         for (const [k, v] of caseEntries) {
           lines.push(`			case ${JSON.stringify(k)}: return ${JSON.stringify(v)}`);
         }
@@ -2012,6 +2363,22 @@ ${goFields.join(`
     return segments.join(" + ");
   }
   resolveDynamicPropValue(expr, signals, memos, propsParams) {
+    const cmpMatch = expr.match(/^(\w+)\(\)\s*([!=]==?)\s*(?:'([^']*)'|(-?\d+(?:\.\d+)?))\s*$/);
+    if (cmpMatch) {
+      const [, depName, op, strLit, numLit] = cmpMatch;
+      const signal = signals.find((sg) => sg.getter === depName);
+      const init = signal?.initialValue.trim();
+      const initMatch = init !== undefined ? /^(?:'([^'\\]*)'|(-?\d+(?:\.\d+)?))$/.exec(init) : null;
+      if (initMatch) {
+        const initVal = initMatch[1] ?? initMatch[2];
+        const litVal = strLit ?? numLit;
+        const sameKind = initMatch[1] !== undefined === (strLit !== undefined);
+        if (sameKind) {
+          const equal = initVal === litVal;
+          return String(op.startsWith("!") ? !equal : equal);
+        }
+      }
+    }
     const getterMatch = expr.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\(\)$/);
     if (getterMatch) {
       const getterName = getterMatch[1];
@@ -2021,7 +2388,7 @@ ${goFields.join(`
       }
       const memo = memos.find((m) => m.name === getterName);
       if (memo) {
-        return this.computeMemoInitialValue(memo, signals, propsParams);
+        return this.computeMemoInitialValueOrNull(memo, signals, propsParams);
       }
     }
     return null;
@@ -2162,6 +2529,19 @@ ${goFields.join(`
     return node.name.text;
   }
   computeMemoInitialValue(memo, signals, propsParams, propFallbackVars = GoTemplateAdapter.EMPTY_PROP_FALLBACK_VARS, goType) {
+    const resolved = this.computeMemoInitialValueOrNull(memo, signals, propsParams, propFallbackVars);
+    if (resolved !== null)
+      return resolved;
+    if (goType === "bool")
+      return "false";
+    if (goType === "string")
+      return '""';
+    if (goType !== undefined && (goType.startsWith("map[") || goType.startsWith("[]") || goType.startsWith("*") || goType.includes("interface{}") || goType === "any")) {
+      return "nil";
+    }
+    return "0";
+  }
+  computeMemoInitialValueOrNull(memo, signals, propsParams, propFallbackVars = GoTemplateAdapter.EMPTY_PROP_FALLBACK_VARS) {
     const computation = memo.computation;
     const propRef = (propName) => {
       const hoisted = propFallbackVars.get(propName);
@@ -2172,6 +2552,52 @@ ${goFields.join(`
     const tmplMemo = this.computeTemplateLiteralMemoInitialValue(computation, propsParams);
     if (tmplMemo !== null)
       return tmplMemo;
+    const eqMatch = computation.match(/^\(\)\s*=>\s*(\w+)\(\)\s*([!=]==?)\s*'([^']*)'\s*$/);
+    if (eqMatch) {
+      const [, depName, op, lit] = eqMatch;
+      const signal = signals.find((sg) => sg.getter === depName);
+      const initLit = signal ? /^'([^'\\]*)'$/.exec(signal.initialValue.trim()) : null;
+      if (initLit) {
+        const equal = initLit[1] === lit;
+        return String(op.startsWith("!") ? !equal : equal);
+      }
+    }
+    const boolPassthrough = computation.match(/^\(\)\s*=>\s*props\.(\w+)\s*\?\?\s*false\s*$/);
+    if (boolPassthrough) {
+      return propRef(boolPassthrough[1]);
+    }
+    const ternMatch = computation.match(/^\(\)\s*=>\s*(\w+)\(\)\s*\?\s*([\w$]+|'[^']*')\s*:\s*([\w$]+|'[^']*')\s*$/);
+    if (ternMatch) {
+      const [, condName, whenTrue, whenFalse] = ternMatch;
+      const resolveBranch = (b) => {
+        const lit = /^'([^']*)'$/.exec(b);
+        if (lit)
+          return JSON.stringify(lit[1]);
+        const constVal = this.moduleStringConsts.get(b);
+        return constVal !== undefined ? JSON.stringify(constVal) : null;
+      };
+      const t = resolveBranch(whenTrue);
+      const f = resolveBranch(whenFalse);
+      if (t !== null && f !== null) {
+        let condGo = null;
+        const condSignal = signals.find((sg) => sg.getter === condName);
+        if (condSignal) {
+          condGo = this.getSignalInitialValueAsGo(condSignal.initialValue, propsParams, propFallbackVars);
+        } else {
+          const condMemo = (this.currentMemos ?? []).find((m) => m.name === condName);
+          if (condMemo) {
+            condGo = this.computeMemoInitialValueOrNull(condMemo, signals, propsParams, propFallbackVars);
+          }
+        }
+        if (condGo === "true")
+          return t;
+        if (condGo === "false")
+          return f;
+        if (condGo !== null) {
+          return `func() string { if ${condGo} { return ${t} }; return ${f} }()`;
+        }
+      }
+    }
     const arithmeticMatch = computation.match(/\(\)\s*=>\s*(\w+)\(\)\s*([*+\-/])\s*(\d+)/);
     if (arithmeticMatch) {
       const [, depName, operator, operand] = arithmeticMatch;
@@ -2191,8 +2617,8 @@ ${goFields.join(`
           return `${hoisted.varName} ${operator} ${operand}`;
         const fieldName = this.capitalizeFieldName(propName);
         if (param.type) {
-          const goType2 = this.typeInfoToGo(param.type, param.defaultValue);
-          if (goType2 === "interface{}")
+          const goType = this.typeInfoToGo(param.type, param.defaultValue);
+          if (goType === "interface{}")
             return `in.${fieldName}.(int) ${operator} ${operand}`;
         }
         return `in.${fieldName} ${operator} ${operand}`;
@@ -2221,8 +2647,8 @@ ${goFields.join(`
       if (param) {
         const fieldName = this.capitalizeFieldName(varName);
         if (param.type) {
-          const goType2 = this.typeInfoToGo(param.type, param.defaultValue);
-          if (goType2 === "interface{}")
+          const goType = this.typeInfoToGo(param.type, param.defaultValue);
+          if (goType === "interface{}")
             return `in.${fieldName}.(int) ${operator} ${operand}`;
         }
         return `in.${fieldName} ${operator} ${operand}`;
@@ -2236,11 +2662,283 @@ ${goFields.join(`
         return `in.${this.capitalizeFieldName(varName)}`;
       }
     }
-    if (goType === "bool")
+    const blockReturn = this.resolveBlockBodyMemoModuleConst(computation, signals);
+    if (blockReturn !== null && blockReturn.constValue && blockReturn.constType) {
+      return this.convertInitialValue(blockReturn.constValue, blockReturn.constType, propsParams);
+    }
+    const objMemo = this.computeObjectMemoInitialValue(computation);
+    if (objMemo !== null)
+      return objMemo;
+    return null;
+  }
+  resolveBlockBodyMemoModuleConst(computation, signals) {
+    try {
+      const sf = ts.createSourceFile("__memo.ts", `const __x = (${computation});`, ts.ScriptTarget.Latest, false);
+      const stmt = sf.statements[0];
+      if (!stmt || !ts.isVariableStatement(stmt))
+        return null;
+      let init = stmt.declarationList.declarations[0]?.initializer;
+      while (init && ts.isParenthesizedExpression(init))
+        init = init.expression;
+      if (!init || !ts.isArrowFunction(init))
+        return null;
+      const body = init.body;
+      if (!ts.isBlock(body))
+        return null;
+      const varToSignal = new Map;
+      let guardSignalGetter = null;
+      let returnedConst = null;
+      for (const s of body.statements) {
+        if (ts.isVariableStatement(s)) {
+          for (const decl of s.declarationList.declarations) {
+            if (ts.isIdentifier(decl.name) && decl.initializer && ts.isCallExpression(decl.initializer) && ts.isIdentifier(decl.initializer.expression)) {
+              const callee = decl.initializer.expression.text;
+              if (signals.some((sg) => sg.getter === callee)) {
+                varToSignal.set(decl.name.text, callee);
+              }
+            }
+          }
+        }
+        if (ts.isIfStatement(s) && ts.isPrefixUnaryExpression(s.expression) && s.expression.operator === ts.SyntaxKind.ExclamationToken && ts.isIdentifier(s.expression.operand)) {
+          const guardVar = s.expression.operand.text;
+          const signalGetter = varToSignal.get(guardVar);
+          if (!signalGetter)
+            continue;
+          const thenBlock = ts.isBlock(s.thenStatement) ? s.thenStatement.statements : [s.thenStatement];
+          for (const rs of thenBlock) {
+            if (ts.isReturnStatement(rs) && rs.expression && ts.isIdentifier(rs.expression)) {
+              guardSignalGetter = signalGetter;
+              returnedConst = rs.expression.text;
+            }
+          }
+        }
+        if (guardSignalGetter && returnedConst)
+          break;
+      }
+      if (!guardSignalGetter || !returnedConst)
+        return null;
+      const guardSignal = signals.find((sg) => sg.getter === guardSignalGetter);
+      if (!guardSignal)
+        return null;
+      const iv = guardSignal.initialValue.trim();
+      if (iv !== "null" && iv !== "''" && iv !== '""' && iv !== "0" && iv !== "false") {
+        return null;
+      }
+      const constant = this.localConstants.find((c) => c.name === returnedConst && c.origin?.scope === "module");
+      if (!constant)
+        return null;
+      return {
+        constName: constant.name,
+        constValue: constant.value,
+        constType: constant.type ?? undefined
+      };
+    } catch {
+      return null;
+    }
+  }
+  computeObjectMemoInitialValue(computation) {
+    const arrow = this.parseLiteralExpression(computation);
+    if (!arrow || !ts.isArrowFunction(arrow) || !ts.isBlock(arrow.body))
+      return null;
+    const searchParamsVars = new Set;
+    let retObj = null;
+    const statements = arrow.body.statements;
+    for (let i = 0;i < statements.length; i++) {
+      const s = statements[i];
+      if (ts.isVariableStatement(s)) {
+        for (const d of s.declarationList.declarations) {
+          if (ts.isIdentifier(d.name) && d.initializer && ts.isCallExpression(d.initializer) && ts.isIdentifier(d.initializer.expression) && d.initializer.arguments.length === 0 && this.searchParamsLocals.has(d.initializer.expression.text)) {
+            searchParamsVars.add(d.name.text);
+          }
+        }
+        continue;
+      }
+      if (ts.isReturnStatement(s)) {
+        if (i !== statements.length - 1 || !s.expression)
+          return null;
+        let e = s.expression;
+        while (ts.isParenthesizedExpression(e))
+          e = e.expression;
+        if (!ts.isObjectLiteralExpression(e))
+          return null;
+        retObj = e;
+        continue;
+      }
+      return null;
+    }
+    if (!retObj || retObj.properties.length === 0)
+      return null;
+    const env = { searchParamsVars, params: new Map };
+    const entries = [];
+    for (const prop of retObj.properties) {
+      if (!ts.isPropertyAssignment(prop))
+        return null;
+      const key = ts.isIdentifier(prop.name) || ts.isStringLiteral(prop.name) ? prop.name.text : null;
+      if (!key)
+        return null;
+      const go = this.lowerCtorExpr(prop.initializer, env);
+      if (go === null)
+        return null;
+      entries.push(`"${this.capitalizeFieldName(key)}": ${go}`);
+    }
+    return `map[string]interface{}{
+		${entries.join(`,
+		`)},
+	}`;
+  }
+  lowerCtorExpr(node, env) {
+    while (ts.isParenthesizedExpression(node))
+      node = node.expression;
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+      return JSON.stringify(node.text);
+    }
+    if (ts.isNumericLiteral(node))
+      return node.text;
+    if (ts.isIdentifier(node)) {
+      const sub = env.params.get(node.text);
+      if (sub !== undefined)
+        return sub;
+      const c = this.localConstants.find((lc) => lc.name === node.text);
+      if (c?.value !== undefined) {
+        if (c.isModule) {
+          const lit = this.parseLiteralExpression(c.value);
+          if (lit && (ts.isStringLiteral(lit) || ts.isNoSubstitutionTemplateLiteral(lit))) {
+            return JSON.stringify(lit.text);
+          }
+          return null;
+        }
+        if (env.consts?.has(node.text))
+          return null;
+        const inner = this.parseLiteralExpression(c.value);
+        if (!inner)
+          return null;
+        return this.lowerCtorExpr(inner, {
+          ...env,
+          consts: new Set([...env.consts ?? [], node.text])
+        });
+      }
+      return null;
+    }
+    if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === this.propsObjectName) {
+      return `in.${this.capitalizeFieldName(node.name.text)}`;
+    }
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+      const method = node.expression.name.text;
+      const recv = node.expression.expression;
+      if (method === "get" && ts.isIdentifier(recv) && env.searchParamsVars.has(recv.text) && node.arguments.length === 1 && ts.isStringLiteral(node.arguments[0])) {
+        return `in.SearchParams.Get(${JSON.stringify(node.arguments[0].text)})`;
+      }
+      if (method === "includes" && node.arguments.length === 1) {
+        const arr = this.lowerCtorStringArray(recv);
+        const elem = this.lowerCtorExpr(node.arguments[0], env);
+        if (arr !== null && elem !== null)
+          return `bf.Includes(${arr}, ${elem})`;
+        return null;
+      }
+      if (method === "replace" && node.arguments.length === 2 && node.arguments[0].kind === ts.SyntaxKind.RegularExpressionLiteral && node.arguments[0].getText() === "/\\/+$/" && (ts.isStringLiteral(node.arguments[1]) || ts.isNoSubstitutionTemplateLiteral(node.arguments[1])) && node.arguments[1].text === "") {
+        const recvGo = this.lowerCtorExpr(recv, env);
+        if (recvGo === null)
+          return null;
+        this.needsStringsImport = true;
+        return `strings.TrimRight(${recvGo}, "/")`;
+      }
+      return null;
+    }
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+      const fnConst = this.localConstants.find((lc) => lc.name === node.expression.text && lc.isModule);
+      if (fnConst?.value) {
+        const fn = this.parseLiteralExpression(fnConst.value);
+        if (fn && ts.isArrowFunction(fn) && !ts.isBlock(fn.body) && fn.parameters.length === node.arguments.length) {
+          const params = new Map(env.params);
+          for (let i = 0;i < fn.parameters.length; i++) {
+            const p = fn.parameters[i];
+            if (!ts.isIdentifier(p.name))
+              return null;
+            const argGo = this.lowerCtorExpr(node.arguments[i], env);
+            if (argGo === null)
+              return null;
+            params.set(p.name.text, argGo);
+          }
+          return this.lowerCtorExpr(fn.body, { searchParamsVars: env.searchParamsVars, params });
+        }
+      }
+      return null;
+    }
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) {
+      const left = this.lowerCtorExpr(node.left, env);
+      if (left === null)
+        return null;
+      let r = node.right;
+      while (ts.isParenthesizedExpression(r))
+        r = r.expression;
+      if ((ts.isStringLiteral(r) || ts.isNoSubstitutionTemplateLiteral(r)) && r.text === "") {
+        return left;
+      }
+      const right = this.lowerCtorExpr(node.right, env);
+      if (right === null)
+        return null;
+      return `func() string { v := ${left}; if v != "" { return v }; return ${right} }()`;
+    }
+    if (ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.BarBarToken) {
+      const left = this.lowerCtorExpr(node.left, env);
+      const right = this.lowerCtorExpr(node.right, env);
+      if (left === null || right === null)
+        return null;
+      return `func() string { v := ${left}; if v != "" { return v }; return ${right} }()`;
+    }
+    if (ts.isConditionalExpression(node)) {
+      const cond = this.lowerCtorCond(node.condition, env);
+      const t = this.lowerCtorExpr(node.whenTrue, env);
+      const f = this.lowerCtorExpr(node.whenFalse, env);
+      if (cond !== null && t !== null && f !== null) {
+        return `func() string { if ${cond} { return ${t} }; return ${f} }()`;
+      }
+      return null;
+    }
+    return null;
+  }
+  lowerCtorCond(node, env) {
+    while (ts.isParenthesizedExpression(node))
+      node = node.expression;
+    if (node.kind === ts.SyntaxKind.TrueKeyword)
+      return "true";
+    if (node.kind === ts.SyntaxKind.FalseKeyword)
       return "false";
-    if (goType === "string")
-      return '""';
-    return "0";
+    if (ts.isPrefixUnaryExpression(node) && node.operator === ts.SyntaxKind.ExclamationToken) {
+      const inner = this.lowerCtorCond(node.operand, env);
+      return inner === null ? null : `!(${inner})`;
+    }
+    if (ts.isBinaryExpression(node)) {
+      const op = node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken ? "&&" : node.operatorToken.kind === ts.SyntaxKind.BarBarToken ? "||" : null;
+      if (op) {
+        const l = this.lowerCtorCond(node.left, env);
+        const r = this.lowerCtorCond(node.right, env);
+        return l !== null && r !== null ? `(${l} ${op} ${r})` : null;
+      }
+    }
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "includes") {
+      return this.lowerCtorExpr(node, env);
+    }
+    return null;
+  }
+  lowerCtorStringArray(node) {
+    let arr = node;
+    if (ts.isIdentifier(node)) {
+      const c = this.localConstants.find((lc) => lc.name === node.text && lc.isModule);
+      if (!c?.value)
+        return null;
+      arr = this.parseLiteralExpression(c.value);
+    }
+    if (!arr || !ts.isArrayLiteralExpression(arr))
+      return null;
+    const elems = [];
+    for (const el of arr.elements) {
+      if (ts.isStringLiteral(el) || ts.isNoSubstitutionTemplateLiteral(el)) {
+        elems.push(JSON.stringify(el.text));
+      } else
+        return null;
+    }
+    return `[]string{${elems.join(", ")}}`;
   }
   isTemplateLiteralMemo(computation) {
     const sf = ts.createSourceFile("__memo.ts", `const __x = (${computation});`, ts.ScriptTarget.Latest, false);
@@ -2296,6 +2994,10 @@ ${goFields.join(`
     if (this.typeInfoToGo(memo.type) === "interface{}" && this.isBooleanMemo(memo, signals, propsParamMap)) {
       return "bool";
     }
+    const blockReturn = this.resolveBlockBodyMemoModuleConst(memo.computation, signals);
+    if (blockReturn?.constType?.kind === "array") {
+      return this.typeInfoToGo(blockReturn.constType);
+    }
     return this.typeInfoToGo(memo.type);
   }
   isBooleanMemo(memo, signals, propsParamMap) {
@@ -2575,6 +3277,9 @@ ${goFields.join(`
     if (element.slotId) {
       hydrationAttrs += ` ${this.renderSlotMarker(element.slotId)}`;
     }
+    if (element.regionId) {
+      hydrationAttrs += ` ${BF_REGION}="${element.regionId}"`;
+    }
     const voidElements = [
       "area",
       "base",
@@ -2603,8 +3308,9 @@ ${goFields.join(`
       }
       return "";
     }
-    const goExpr = this.convertExpressionToGo(expr.expr);
-    if (goExpr.startsWith("{{")) {
+    const classify = {};
+    const goExpr = this.convertExpressionToGo(expr.expr, classify);
+    if (this.isTemplateFragment(goExpr, classify.parsed?.kind)) {
       if (expr.slotId) {
         return `{{bfTextStart "${expr.slotId}"}}${goExpr}{{bfTextEnd}}`;
       }
@@ -2615,6 +3321,9 @@ ${goFields.join(`
     }
     return `{{${goExpr}}}`;
   }
+  isTemplateFragment(go, kind) {
+    return go.startsWith("{{") || kind === "template-literal";
+  }
   renderClientOnlyConditional(cond) {
     if (cond.slotId) {
       return `{{bfComment "cond-start:${cond.slotId}"}}{{bfComment "cond-end:${cond.slotId}"}}`;
@@ -2625,6 +3334,8 @@ ${goFields.join(`
     return emitParsedExpr(expr, this);
   }
   identifier(name) {
+    if (name === "undefined" || name === "null")
+      return '""';
     for (let i = this.loopBindingStack.length - 1;i >= 0; i--) {
       const acc = this.loopBindingStack[i].get(name);
       if (acc !== undefined)
@@ -2633,6 +3344,9 @@ ${goFields.join(`
     const inlined = this.resolveModuleStringConst(name);
     if (inlined !== null)
       return inlined;
+    const inlinedNum = this.resolveModuleNumericConst(name);
+    if (inlinedNum !== null)
+      return inlinedNum;
     const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1];
     if (currentLoopParam && name === currentLoopParam)
       return ".";
@@ -2640,7 +3354,86 @@ ${goFields.join(`
       return `$${name}`;
     if (this.loopVarRefCount.has(name))
       return `$${name}`;
-    return this.rootFieldRef(name);
+    if (this.localConstants.some((c) => c.name === name && !c.isModule && !c.containsArrow)) {
+      this.referencedDerivedConsts.add(name);
+    }
+    return this.searchParamsFieldRef(name) ?? this.rootFieldRef(name);
+  }
+  computeDerivedConstFields(takenFieldNames) {
+    const fields = [];
+    for (const name of this.referencedDerivedConsts) {
+      const fieldName = this.capitalizeFieldName(name);
+      if (takenFieldNames.has(fieldName))
+        continue;
+      const c = this.localConstants.find((lc) => lc.name === name && !lc.isModule && lc.value);
+      if (!c?.value)
+        continue;
+      const expr = this.parseLiteralExpression(c.value);
+      if (!expr)
+        continue;
+      if (!this.isStringExpr(expr, new Set))
+        continue;
+      const init = this.lowerCtorExpr(expr, {
+        searchParamsVars: new Set,
+        params: new Map,
+        consts: new Set([name])
+      });
+      if (init === null)
+        continue;
+      fields.push({ name: fieldName, init });
+    }
+    return fields;
+  }
+  isStringExpr(node, seen) {
+    while (ts.isParenthesizedExpression(node))
+      node = node.expression;
+    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node) || ts.isTemplateExpression(node)) {
+      return true;
+    }
+    if (ts.isBinaryExpression(node)) {
+      const op = node.operatorToken.kind;
+      if (op === ts.SyntaxKind.PlusToken) {
+        return this.isStringExpr(node.left, seen) || this.isStringExpr(node.right, seen);
+      }
+      if (op === ts.SyntaxKind.BarBarToken || op === ts.SyntaxKind.QuestionQuestionToken) {
+        return this.isStringExpr(node.left, seen) && this.isStringExpr(node.right, seen);
+      }
+      return false;
+    }
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+      const m = node.expression.name.text;
+      const STRING_METHODS = new Set([
+        "replace",
+        "trim",
+        "trimStart",
+        "trimEnd",
+        "toLowerCase",
+        "toUpperCase",
+        "slice",
+        "substring",
+        "substr",
+        "padStart",
+        "padEnd",
+        "concat",
+        "repeat",
+        "get"
+      ]);
+      return STRING_METHODS.has(m);
+    }
+    if (ts.isConditionalExpression(node)) {
+      return this.isStringExpr(node.whenTrue, seen) && this.isStringExpr(node.whenFalse, seen);
+    }
+    if (ts.isIdentifier(node)) {
+      if (seen.has(node.text))
+        return false;
+      const c = this.localConstants.find((lc) => lc.name === node.text && !lc.isModule && lc.value);
+      if (c?.value) {
+        const inner = this.parseLiteralExpression(c.value);
+        if (inner)
+          return this.isStringExpr(inner, new Set([...seen, node.text]));
+      }
+    }
+    return false;
   }
   isOuterLoopParam(name) {
     const top = this.loopParamStack.length - 1;
@@ -2654,70 +3447,26 @@ ${goFields.join(`
     const prefix = this.loopParamStack.length > 0 ? "$." : ".";
     return `${prefix}${this.capitalizeFieldName(name)}`;
   }
+  searchParamsFieldRef(name) {
+    return this.searchParamsLocals.has(name) ? this.rootFieldRef("searchParams") : null;
+  }
   collectModuleStringConsts(constants) {
-    const map = new Map;
-    for (const c of constants ?? []) {
-      if (!c.isModule)
-        continue;
-      if (c.value === undefined)
-        continue;
-      const literal = this.parsePureStringLiteral(c.value);
-      if (literal !== null)
-        map.set(c.name, literal);
-    }
-    return map;
+    return collectModuleStringConstsShared(constants);
   }
-  parsePureStringLiteral(source) {
-    const sf = ts.createSourceFile("__const.ts", `const __x = (${source});`, ts.ScriptTarget.Latest, false);
-    const stmt = sf.statements[0];
-    if (!stmt || !ts.isVariableStatement(stmt))
-      return null;
-    const decl = stmt.declarationList.declarations[0];
-    let init = decl?.initializer;
-    while (init && ts.isParenthesizedExpression(init))
-      init = init.expression;
-    if (!init)
+  resolveModuleStringConst(name) {
+    if (this.loopParamStack.length > 0 && this.loopParamStack[this.loopParamStack.length - 1] === name) {
       return null;
-    if (ts.isStringLiteral(init) || ts.isNoSubstitutionTemplateLiteral(init)) {
-      return init.text;
     }
-    const joined = this.evalStringArrayJoin(init);
-    if (joined !== null)
-      return joined;
-    return null;
-  }
-  evalStringArrayJoin(node) {
-    if (!ts.isCallExpression(node))
-      return null;
-    const callee = node.expression;
-    if (!ts.isPropertyAccessExpression(callee))
+    if (this.loopVarRefCount.has(name))
       return null;
-    if (callee.name.text !== "join")
+    if (this.isOuterLoopParam(name))
       return null;
-    let recv = callee.expression;
-    while (ts.isParenthesizedExpression(recv))
-      recv = recv.expression;
-    if (!ts.isArrayLiteralExpression(recv))
+    const value = this.moduleStringConsts.get(name);
+    if (value === undefined)
       return null;
-    const parts = [];
-    for (const el of recv.elements) {
-      if (ts.isStringLiteral(el) || ts.isNoSubstitutionTemplateLiteral(el)) {
-        parts.push(el.text);
-      } else {
-        return null;
-      }
-    }
-    let sep = ",";
-    if (node.arguments.length >= 1) {
-      const arg = node.arguments[0];
-      if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg))
-        sep = arg.text;
-      else
-        return null;
-    }
-    return parts.join(sep);
+    return `"${this.escapeGoString(value)}"`;
   }
-  resolveModuleStringConst(name) {
+  resolveModuleNumericConst(name) {
     if (this.loopParamStack.length > 0 && this.loopParamStack[this.loopParamStack.length - 1] === name) {
       return null;
     }
@@ -2725,10 +3474,11 @@ ${goFields.join(`
       return null;
     if (this.isOuterLoopParam(name))
       return null;
-    const value = this.moduleStringConsts.get(name);
-    if (value === undefined)
+    const c = this.localConstants.find((k) => k.name === name && k.isModule && !k.containsArrow);
+    if (!c || c.value === undefined)
       return null;
-    return `"${this.escapeGoString(value)}"`;
+    const v = c.value.trim().replace(/(?<=\d)_(?=\d)/g, "");
+    return /^-?\d+(\.\d+)?$/.test(v) ? v : null;
   }
   literal(value, literalType) {
     if (literalType === "string")
@@ -2739,7 +3489,7 @@ ${goFields.join(`
   }
   call(callee, args, emit) {
     if (callee.kind === "identifier" && args.length === 0) {
-      return this.rootFieldRef(callee.name);
+      return this.searchParamsFieldRef(callee.name) ?? this.rootFieldRef(callee.name);
     }
     const path = identifierPath(callee);
     if (path && this.templatePrimitives[path]) {
@@ -2770,6 +3520,13 @@ ${goFields.join(`
       if (result)
         return result;
     }
+    if (property === "length" && object.kind === "call" && object.callee.kind === "identifier" && object.args.length === 0) {
+      const slice = this.memoBackedLoopSlice.get(object.callee.name);
+      if (slice) {
+        const prefix = this.loopParamStack.length > 0 ? "$." : ".";
+        return `len ${prefix}${slice}`;
+      }
+    }
     if (object.kind === "higher-order" && (object.method === "find" || object.method === "findLast")) {
       const findResult = this.renderHigherOrderExpr(object, emit);
       if (findResult) {
@@ -2782,6 +3539,11 @@ ${goFields.join(`
     if (object.kind === "identifier" && this.propsObjectName && object.name === this.propsObjectName) {
       return this.rootFieldRef(property);
     }
+    if (object.kind === "identifier") {
+      const staticValue = this.resolveStaticRecordLiteralIndex(`${object.name}.${property}`);
+      if (staticValue !== null)
+        return staticValue;
+    }
     const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1];
     if (object.kind === "identifier" && currentLoopParam && object.name === currentLoopParam) {
       return `.${this.capitalizeFieldName(property)}`;
@@ -2791,34 +3553,43 @@ ${goFields.join(`
       return `len ${obj}`;
     return `${obj}.${this.capitalizeFieldName(property)}`;
   }
+  indexAccess(object, index, emit) {
+    return `index ${wrapIfMultiToken(emit(object))} ${wrapIfMultiToken(emit(index))}`;
+  }
   binary(op, left, right, emit) {
     const l = emit(left);
     const r = emit(right);
+    const wl = wrapIfMultiToken(l);
+    const wr = wrapIfMultiToken(r);
     switch (op) {
       case "===":
-      case "==":
-        return `eq ${l} ${r}`;
+      case "==": {
+        const [el, er] = stringTolerantEqOperands(l, r);
+        return `eq ${wrapIfMultiToken(el)} ${wrapIfMultiToken(er)}`;
+      }
       case "!==":
-      case "!=":
-        return `ne ${l} ${r}`;
+      case "!=": {
+        const [el, er] = stringTolerantEqOperands(l, r);
+        return `ne ${wrapIfMultiToken(el)} ${wrapIfMultiToken(er)}`;
+      }
       case ">":
-        return `gt ${l} ${r}`;
+        return `gt ${wl} ${wr}`;
       case "<":
-        return `lt ${l} ${r}`;
+        return `lt ${wl} ${wr}`;
       case ">=":
-        return `ge ${l} ${r}`;
+        return `ge ${wl} ${wr}`;
       case "<=":
-        return `le ${l} ${r}`;
+        return `le ${wl} ${wr}`;
       case "+":
-        return `bf_add ${l} ${r}`;
+        return `bf_add ${wl} ${wr}`;
       case "-":
-        return `bf_sub ${l} ${r}`;
+        return `bf_sub ${wl} ${wr}`;
       case "*":
-        return `bf_mul ${l} ${r}`;
+        return `bf_mul ${wl} ${wr}`;
       case "/":
-        return `bf_div ${l} ${r}`;
+        return `bf_div ${wl} ${wr}`;
       case "%":
-        return `bf_mod ${l} ${r}`;
+        return `bf_mod ${wl} ${wr}`;
       default:
         return `${l} ${op} ${r}`;
     }
@@ -2832,10 +3603,8 @@ ${goFields.join(`
     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;
+    const wrapLeft = wrapIfMultiToken(emit(left));
+    const wrapRight = wrapIfMultiToken(emit(right));
     if (op === "&&")
       return `and ${wrapLeft} ${wrapRight}`;
     return `or ${wrapLeft} ${wrapRight}`;
@@ -2852,7 +3621,8 @@ ${goFields.join(`
       if (part.type === "string") {
         result += part.value;
       } else {
-        result += `{{${emit(part.expr)}}}`;
+        const e = emit(part.expr);
+        result += this.isTemplateFragment(e, part.expr.kind) ? e : `{{${e}}}`;
       }
     }
     return result;
@@ -2953,6 +3723,11 @@ ${goFields.join(`
         const recv = emit(object);
         return `bf_trim ${wrapIfMultiToken(recv)}`;
       }
+      case "toFixed": {
+        const recv = emit(object);
+        const digits = args.length >= 1 ? emit(args[0]) : "0";
+        return `bf_to_fixed ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(digits)}`;
+      }
       case "split": {
         const recv = emit(object);
         if (args.length === 0) {
@@ -3438,11 +4213,33 @@ ${goFields.join(`
         return false;
     }
   }
-  convertExpressionToGo(jsExpr) {
+  convertExpressionToGo(jsExpr, out) {
     const trimmed = jsExpr.trim();
     if (trimmed === "null" || trimmed === "undefined") {
       return '""';
     }
+    const staticIndexed = this.resolveStaticRecordLiteralIndex(trimmed);
+    if (staticIndexed !== null) {
+      return staticIndexed;
+    }
+    if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) {
+      const litConst = (this.localConstants ?? []).find((c) => c.name === trimmed);
+      if (litConst?.value !== undefined) {
+        const v = litConst.value.trim();
+        if (/^-?\d+(\.\d+)?$/.test(v))
+          return v;
+        const strLit = /^'([^'\\]*)'$/.exec(v) ?? /^"([^"\\]*)"$/.exec(v);
+        if (strLit)
+          return JSON.stringify(strLit[1]);
+      }
+    }
+    const urlBuilt = this.lowerUrlBuilderHelperCall(trimmed);
+    if (urlBuilt !== null)
+      return urlBuilt;
+    const inlined = this.inlineLocalHelperCall(trimmed);
+    if (inlined !== null) {
+      return this.convertExpressionToGo(inlined, out);
+    }
     const parsed = parseExpression(trimmed);
     const support = isSupported(parsed);
     if (!support.supported) {
@@ -3457,8 +4254,270 @@ ${goFields.join(`
       });
       return `""`;
     }
+    if (out)
+      out.parsed = parsed;
     return this.renderParsedExpr(parsed);
   }
+  inlineLocalHelperCall(jsExpr) {
+    if (this.localHelperNames.size === 0)
+      return null;
+    const head = /^\s*([A-Za-z_$][\w$]*)\s*\(/.exec(jsExpr);
+    if (!head || !this.localHelperNames.has(head[1]))
+      return null;
+    const call = this.parseLiteralExpression(jsExpr);
+    if (!call || !ts.isCallExpression(call) || !ts.isIdentifier(call.expression))
+      return null;
+    if (call.arguments.some((a) => ts.isSpreadElement(a)))
+      return null;
+    const fnConst = this.localConstants.find((c) => c.name === call.expression.text && !c.isModule && c.value);
+    if (!fnConst?.value)
+      return null;
+    const fn = this.parseLiteralExpression(fnConst.value);
+    if (!fn || !ts.isArrowFunction(fn) || ts.isBlock(fn.body))
+      return null;
+    if (fn.parameters.length !== call.arguments.length)
+      return null;
+    if (this.bodyCallsLocalHelper(fn.body))
+      return null;
+    const subs = new Map;
+    for (let i = 0;i < fn.parameters.length; i++) {
+      const p = fn.parameters[i];
+      if (!ts.isIdentifier(p.name))
+        return null;
+      subs.set(p.name.text, `(${call.arguments[i].getText()})`);
+    }
+    if (!this.isSpliceSafeHelperBody(fn.body, new Set(subs.keys())))
+      return null;
+    return this.substituteHelperParams(fn.body, subs);
+  }
+  isSpliceSafeHelperBody(body, paramNames) {
+    let safe = true;
+    const visit = (n) => {
+      if (!safe)
+        return;
+      if (ts.isArrowFunction(n) || ts.isFunctionExpression(n) || ts.isFunctionDeclaration(n)) {
+        safe = false;
+        return;
+      }
+      if (ts.isShorthandPropertyAssignment(n) && paramNames.has(n.name.text)) {
+        safe = false;
+        return;
+      }
+      ts.forEachChild(n, visit);
+    };
+    visit(body);
+    return safe;
+  }
+  bodyCallsLocalHelper(body) {
+    let found = false;
+    const visit = (n) => {
+      if (found)
+        return;
+      if (ts.isCallExpression(n) && ts.isIdentifier(n.expression)) {
+        const name = n.expression.text;
+        if (this.localConstants.some((c) => c.name === name && !c.isModule && c.containsArrow)) {
+          found = true;
+          return;
+        }
+      }
+      ts.forEachChild(n, visit);
+    };
+    visit(body);
+    return found;
+  }
+  substituteHelperParams(body, subs) {
+    const sf = body.getSourceFile();
+    const base = body.getStart(sf);
+    const repls = [];
+    const visit = (node) => {
+      if (ts.isPropertyAccessExpression(node)) {
+        visit(node.expression);
+        return;
+      }
+      if (ts.isPropertyAssignment(node)) {
+        if (ts.isComputedPropertyName(node.name))
+          visit(node.name);
+        visit(node.initializer);
+        return;
+      }
+      if (ts.isIdentifier(node)) {
+        const sub = subs.get(node.text);
+        if (sub !== undefined) {
+          repls.push({ start: node.getStart(sf) - base, end: node.getEnd() - base, text: sub });
+          return;
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(body);
+    let text = body.getText(sf);
+    for (const r of repls.sort((a, b) => b.start - a.start)) {
+      text = text.slice(0, r.start) + r.text + text.slice(r.end);
+    }
+    return text;
+  }
+  lowerUrlBuilderHelperCall(jsExpr) {
+    if (this.localHelperNames.size === 0)
+      return null;
+    const head = /^\s*([A-Za-z_$][\w$]*)\s*\(/.exec(jsExpr);
+    if (!head || !this.localHelperNames.has(head[1]))
+      return null;
+    const call = this.parseLiteralExpression(jsExpr);
+    if (!call || !ts.isCallExpression(call) || !ts.isIdentifier(call.expression))
+      return null;
+    if (call.arguments.some((a) => ts.isSpreadElement(a)))
+      return null;
+    const fnConst = this.localConstants.find((c) => c.name === call.expression.text && !c.isModule && c.value);
+    if (!fnConst?.value)
+      return null;
+    const fn = this.parseLiteralExpression(fnConst.value);
+    if (!fn || !ts.isArrowFunction(fn) || fn.parameters.length !== call.arguments.length)
+      return null;
+    const subs = new Map;
+    for (let i = 0;i < fn.parameters.length; i++) {
+      const p = fn.parameters[i];
+      if (!ts.isIdentifier(p.name))
+        return null;
+      subs.set(p.name.text, `(${call.arguments[i].getText()})`);
+    }
+    const shape = this.extractUrlBuilder(fn);
+    if (shape)
+      return this.emitUrlBuilder(shape, subs);
+    if (!ts.isBlock(fn.body)) {
+      let body = fn.body;
+      while (ts.isParenthesizedExpression(body))
+        body = body.expression;
+      if (ts.isCallExpression(body) && ts.isIdentifier(body.expression) && this.localHelperNames.has(body.expression.text)) {
+        return this.lowerUrlBuilderHelperCall(this.substituteHelperParams(body, subs));
+      }
+    }
+    return null;
+  }
+  extractUrlBuilder(arrow) {
+    if (!ts.isBlock(arrow.body))
+      return null;
+    let builderVar = null;
+    let base = null;
+    const sets = [];
+    for (const s of arrow.body.statements) {
+      if (ts.isVariableStatement(s)) {
+        for (const d of s.declarationList.declarations) {
+          if (ts.isIdentifier(d.name) && d.initializer && ts.isNewExpression(d.initializer) && ts.isIdentifier(d.initializer.expression) && d.initializer.expression.text === "URLSearchParams" && (d.initializer.arguments?.length ?? 0) === 0) {
+            builderVar = d.name.text;
+          }
+        }
+        continue;
+      }
+      if (ts.isIfStatement(s) && !s.elseStatement && builderVar) {
+        const set = this.matchUrlSet(s.thenStatement, builderVar);
+        if (!set)
+          return null;
+        sets.push({ guard: s.expression, key: set.key, value: set.value });
+        continue;
+      }
+      if (ts.isExpressionStatement(s) && builderVar) {
+        const set = this.matchUrlSet(s, builderVar);
+        if (set) {
+          sets.push({ guard: null, key: set.key, value: set.value });
+          continue;
+        }
+        return null;
+      }
+      if (ts.isReturnStatement(s) && s.expression) {
+        let e = s.expression;
+        while (ts.isParenthesizedExpression(e))
+          e = e.expression;
+        if (!ts.isConditionalExpression(e))
+          return null;
+        base = e.whenFalse;
+        continue;
+      }
+      return null;
+    }
+    if (!builderVar || !base || sets.length === 0)
+      return null;
+    return { base, sets };
+  }
+  matchUrlSet(node, builderVar) {
+    const stmt = ts.isBlock(node) ? node.statements.length === 1 ? node.statements[0] : null : node;
+    if (!stmt || !ts.isExpressionStatement(stmt))
+      return null;
+    const call = stmt.expression;
+    if (ts.isCallExpression(call) && ts.isPropertyAccessExpression(call.expression) && ts.isIdentifier(call.expression.expression) && call.expression.expression.text === builderVar && call.expression.name.text === "set" && call.arguments.length === 2 && ts.isStringLiteral(call.arguments[0])) {
+      return { key: call.arguments[0].text, value: call.arguments[1] };
+    }
+    return null;
+  }
+  emitUrlBuilder(shape, subs) {
+    const lowerExpr = (n) => this.convertExpressionToGo(this.substituteHelperParams(n, subs));
+    const baseGo = wrapIfMultiToken(lowerExpr(shape.base));
+    const parts = [baseGo];
+    for (const set of shape.sets) {
+      const guardGo = set.guard ? this.lowerUrlGuard(set.guard, subs) : "true";
+      parts.push(`(${guardGo})`);
+      parts.push(JSON.stringify(set.key));
+      parts.push(wrapIfMultiToken(lowerExpr(set.value)));
+    }
+    return `bf_query ${parts.join(" ")}`;
+  }
+  lowerUrlGuard(guard, subs) {
+    let g = guard;
+    while (ts.isParenthesizedExpression(g))
+      g = g.expression;
+    const isBoolShape = ts.isBinaryExpression(g) && [
+      ts.SyntaxKind.EqualsEqualsToken,
+      ts.SyntaxKind.EqualsEqualsEqualsToken,
+      ts.SyntaxKind.ExclamationEqualsToken,
+      ts.SyntaxKind.ExclamationEqualsEqualsToken,
+      ts.SyntaxKind.LessThanToken,
+      ts.SyntaxKind.GreaterThanToken,
+      ts.SyntaxKind.LessThanEqualsToken,
+      ts.SyntaxKind.GreaterThanEqualsToken
+    ].includes(g.operatorToken.kind) || ts.isPrefixUnaryExpression(g) && g.operator === ts.SyntaxKind.ExclamationToken || g.kind === ts.SyntaxKind.TrueKeyword || g.kind === ts.SyntaxKind.FalseKeyword;
+    if (isBoolShape) {
+      return this.convertConditionToGo(this.substituteHelperParams(guard, subs)).condition;
+    }
+    const valueGo = wrapIfMultiToken(this.convertExpressionToGo(this.substituteHelperParams(guard, subs)));
+    return `ne ${valueGo} ""`;
+  }
+  resolveStaticRecordLiteralIndex(jsExpr) {
+    const m = /^([A-Za-z_$][\w$]*)\[\s*(?:'([^']*)'|"([^"]*)")\s*\]$/.exec(jsExpr) ?? /^([A-Za-z_$][\w$]*)\.([A-Za-z_$][\w$]*)$/.exec(jsExpr);
+    if (!m)
+      return null;
+    const key = m[2] ?? m[3];
+    const constInfo = (this.localConstants ?? []).find((c) => c.name === m[1] && c.isModule);
+    if (constInfo?.value === undefined)
+      return null;
+    const sf = ts.createSourceFile("__rec.ts", `(${constInfo.value})`, ts.ScriptTarget.Latest, true);
+    if (sf.statements.length !== 1)
+      return null;
+    const stmt = sf.statements[0];
+    if (!ts.isExpressionStatement(stmt))
+      return null;
+    let parsed = stmt.expression;
+    while (ts.isParenthesizedExpression(parsed))
+      parsed = parsed.expression;
+    if (!ts.isObjectLiteralExpression(parsed))
+      return null;
+    for (const prop of parsed.properties) {
+      if (!ts.isPropertyAssignment(prop))
+        continue;
+      const name = prop.name;
+      const propKey = ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNoSubstitutionTemplateLiteral(name) ? name.text : null;
+      if (propKey !== key)
+        continue;
+      let v = prop.initializer;
+      while (ts.isParenthesizedExpression(v))
+        v = v.expression;
+      if (ts.isNumericLiteral(v))
+        return v.text;
+      if (ts.isStringLiteral(v) || ts.isNoSubstitutionTemplateLiteral(v)) {
+        return JSON.stringify(v.text);
+      }
+      return null;
+    }
+    return null;
+  }
   makeLoc() {
     return {
       file: this.componentName + ".tsx",
@@ -3632,6 +4691,14 @@ ${goFields.join(`
         }
         return { preamble: obj.preamble, expr: `${obj.expr}.${this.capitalizeFieldName(expr.property)}` };
       }
+      case "index-access": {
+        const obj = this.renderConditionExpr(expr.object);
+        const idx = this.renderConditionExpr(expr.index);
+        return {
+          preamble: obj.preamble + idx.preamble,
+          expr: `index ${wrapIfMultiToken(obj.expr)} ${wrapIfMultiToken(idx.expr)}`
+        };
+      }
       case "binary": {
         const leftNeedsParens = this.needsParensInGoTemplate(expr.left);
         const leftResult = this.renderConditionExpr(expr.left);
@@ -3643,13 +4710,17 @@ ${goFields.join(`
         let result;
         switch (expr.op) {
           case "===":
-          case "==":
-            result = `eq ${left} ${right}`;
+          case "==": {
+            const [el, er] = stringTolerantEqOperands(left, right);
+            result = `eq ${el} ${er}`;
             break;
+          }
           case "!==":
-          case "!=":
-            result = `ne ${left} ${right}`;
+          case "!=": {
+            const [el, er] = stringTolerantEqOperands(left, right);
+            result = `ne ${el} ${er}`;
             break;
+          }
           case ">":
             result = `gt ${left} ${right}`;
             break;
@@ -3840,6 +4911,45 @@ ${goFields.join(`
     }
     return null;
   }
+  queueDynamicChildrenDefine(comp) {
+    const effectiveChildren = comp.children.length > 0 ? comp.children : this.jsxChildrenPropNodes(comp.props);
+    if (effectiveChildren.length === 0)
+      return null;
+    if (this.extractTextChildren(effectiveChildren) !== null)
+      return null;
+    if (this.extractHtmlChildren(effectiveChildren) !== null)
+      return null;
+    if (this.extractScopedHtmlChildren(effectiveChildren) !== null)
+      return null;
+    const name = `${this.componentName}__children_${comp.slotId}`;
+    if (!this.pendingChildrenDefines.some((d) => d.name === name)) {
+      this.pendingChildrenDefines.push({
+        name,
+        content: this.renderChildren(effectiveChildren)
+      });
+    }
+    return name;
+  }
+  queueLoopBodyChildrenDefine(comp) {
+    const effectiveChildren = comp.children.length > 0 ? comp.children : this.jsxChildrenPropNodes(comp.props);
+    if (effectiveChildren.length === 0)
+      return null;
+    if (this.extractTextChildren(effectiveChildren) !== null)
+      return null;
+    if (this.extractHtmlChildren(effectiveChildren) !== null)
+      return null;
+    if (this.extractScopedHtmlChildren(effectiveChildren) !== null)
+      return null;
+    const name = `${this.componentName}__loop_children_${comp.slotId}`;
+    if (!this.pendingChildrenDefines.some((d) => d.name === name)) {
+      const wasInLoop = this.inLoop;
+      this.inLoop = false;
+      const content = this.renderChildren(effectiveChildren);
+      this.inLoop = wasInLoop;
+      this.pendingChildrenDefines.push({ name, content });
+    }
+    return name;
+  }
   renderComponent(comp, ctx) {
     if (comp.name === "Portal") {
       return this.renderPortalComponent(comp);
@@ -3849,10 +4959,16 @@ ${goFields.join(`
     }
     let templateCall;
     if (this.inLoop) {
-      templateCall = `{{template "${comp.name}" .}}`;
+      const loopBodyDefine = this.queueLoopBodyChildrenDefine(comp);
+      if (loopBodyDefine) {
+        templateCall = `{{template "${comp.name}" (bf_with_children . (bf_tmpl "${loopBodyDefine}" .))}}`;
+      } else {
+        templateCall = `{{template "${comp.name}" .}}`;
+      }
     } else if (comp.slotId) {
       const suffix = slotIdToFieldSuffix(comp.slotId);
-      templateCall = `{{template "${comp.name}" .${comp.name}${suffix}}}`;
+      const childrenDefine = this.queueDynamicChildrenDefine(comp);
+      templateCall = childrenDefine ? `{{template "${comp.name}" (bf_with_children .${comp.name}${suffix} (bf_tmpl "${childrenDefine}" .))}}` : `{{template "${comp.name}" .${comp.name}${suffix}}}`;
     } else {
       templateCall = `{{template "${comp.name}" .${comp.name}}}`;
     }
@@ -3899,10 +5015,22 @@ ${children}`;
       }
       if (isBooleanAttr(name) || value.presenceOrUndefined) {
         const { condition: goCond, preamble } = this.convertConditionToGo(value.expr);
-        return `${preamble}{{if ${goCond}}}${name}{{end}}`;
+        const body = name.startsWith("aria-") ? `${name}="true"` : name;
+        return `${preamble}{{if ${goCond}}}${body}{{end}}`;
       }
       const parsed = parseExpression(value.expr.trim());
-      if (parsed.kind === "conditional" || parsed.kind === "template-literal") {
+      if (parsed.kind === "conditional") {
+        const undef = (e) => e.kind === "identifier" && (e.name === "undefined" || e.name === "null") || e.kind === "literal" && (e.value === null || e.value === undefined);
+        const test = parsed.test;
+        if (undef(parsed.alternate) && !undef(parsed.consequent)) {
+          const { condition: goCond, preamble } = this.convertConditionToGo(this.isTemplateFragment(this.renderParsedExpr(test), test.kind) ? value.expr : value.expr.slice(0, value.expr.indexOf("?")).trim());
+          const valueExpr = this.renderParsedExpr(parsed.consequent);
+          const body = `${name}="{{${valueExpr}}}"`;
+          return `${preamble}{{if ${goCond}}}${body}{{end}}`;
+        }
+        return `${name}="${this.renderParsedExpr(parsed)}"`;
+      }
+      if (parsed.kind === "template-literal") {
         return `${name}="${this.renderParsedExpr(parsed)}"`;
       }
       const bareId = value.expr.trim();
@@ -3911,7 +5039,9 @@ ${children}`;
         const field = `.${this.capitalizeFieldName(propName)}`;
         return `{{if ne ${field} nil}}${name}="{{${this.convertExpressionToGo(value.expr)}}}"{{end}}`;
       }
-      return `${name}="{{${this.convertExpressionToGo(value.expr)}}}"`;
+      const exprOut = {};
+      const go = this.convertExpressionToGo(value.expr, exprOut);
+      return this.isTemplateFragment(go, exprOut.parsed?.kind) ? `${name}="${go}"` : `${name}="{{${go}}}"`;
     },
     emitBooleanAttr: (_value, name) => name,
     emitSpread: (value) => {
@@ -3985,7 +5115,21 @@ ${children}`;
       }
       const inner = s.slice(open + 2, close).trim();
       if (inner) {
-        out += `{{${this.convertExpressionToGo(inner)}}}`;
+        const cls = {};
+        const goExpr = this.convertExpressionToGo(inner, cls);
+        const parsed = cls.parsed;
+        if (parsed?.kind === "template-literal") {
+          for (const part of parsed.parts) {
+            if (part.type === "string") {
+              out += this.escapeAttrText(part.value);
+            } else {
+              const e = this.renderParsedExpr(part.expr);
+              out += this.isTemplateFragment(e, part.expr.kind) ? e : `{{${e}}}`;
+            }
+          }
+        } else {
+          out += this.isTemplateFragment(goExpr, parsed?.kind) ? goExpr : `{{${goExpr}}}`;
+        }
       } else {
         out += s.slice(open, close + 1);
       }
@@ -4005,7 +5149,8 @@ ${children}`;
         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 rawKeyExpr = this.convertExpressionToGo(part.key);
+        const keyExpr = /\s/.test(rawKeyExpr) ? `(${rawKeyExpr})` : rawKeyExpr;
         const caseEntries = Object.entries(part.cases);
         if (caseEntries.length === 0)
           continue;
@@ -4154,6 +5299,8 @@ function combineGoTypes(options) {
   const stdlibImports = [`	"math/rand"`];
   if (/\bfmt\./.test(usageScan))
     stdlibImports.push(`	"fmt"`);
+  if (/\bstrings\./.test(usageScan))
+    stdlibImports.push(`	"strings"`);
   if (/\btemplate\.HTML\b/.test(usageScan))
     stdlibImports.push(`	"html/template"`);
   stdlibImports.sort();