@barefootjs/go-template 0.17.0 → 0.18.0

package/dist/build.js

@@ -371,17 +371,18 @@ import {
   isSupported,
   exprToString,
   identifierPath,
-  asCallbackMethodCall,
+  asCallbackMethodCall as asCallbackMethodCall3,
   sortComparatorFromArrow,
   emitParsedExpr,
   emitIRNode,
   emitAttrValue,
   augmentInheritedPropAccesses,
   collectContextConsumers,
-  isLowerableObjectRestDestructure,
+  isLowerableLoopDestructure,
   collectModuleStringConsts as collectModuleStringConstsShared,
-  searchParamsLocalNames,
-  prepareLoweringMatchers
+  prepareLoweringMatchers,
+  envSignalReaderFor,
+  computeSsrSeedPlan
 } from "@barefootjs/jsx";
 import { findInterpolationEnd } from "@barefootjs/jsx/scanner";
 import { BF_REGION } from "@barefootjs/shared";
@@ -462,6 +463,13 @@ function capitalizeFieldName(name) {
   }
   return name.charAt(0).toUpperCase() + name.slice(1);
 }
+function goFieldNameForKey(key) {
+  const parts = key.split(/[^A-Za-z0-9_]+/).filter(Boolean);
+  if (parts.length === 0)
+    return "Field";
+  const name = parts.map(capitalizeFieldName).join("");
+  return /^[0-9]/.test(name) ? `Field${name}` : name;
+}
 function slotIdToFieldSuffix(slotId) {
   const cleanId = slotId.startsWith("^") ? slotId.slice(1) : slotId;
   const match = cleanId.match(/^s(\d+)$/);
@@ -564,6 +572,13 @@ function emitFlatMapEval(recv, body, param, emit) {
   const env = emitEvalEnvArg(body, [param], emit);
   return `bf_flat_map_eval ${wrapIfMultiToken(recv)} "${escapeGoString(json)}" "${param}" ${env}`;
 }
+function emitMapEval(recv, body, param, emit) {
+  const json = serializeParsedExpr(body);
+  if (json === null)
+    return null;
+  const env = emitEvalEnvArg(body, [param], emit);
+  return `bf_map_eval ${wrapIfMultiToken(recv)} "${escapeGoString(json)}" "${param}" ${env}`;
+}
 function stringTolerantEqOperands(l, r) {
   const isStrLit = (x) => /^"(?:[^"\\]|\\.)*"$/.test(x);
   if (isStrLit(l) === isStrLit(r))
@@ -677,6 +692,9 @@ class CompileState {
   currentTypeDefinitions = [];
   contextConsumers = [];
   searchParamsLocals = new Set;
+  envSignalReadersByLocal = new Map;
+  ssrSeedPlan = { baseScope: [], steps: [] };
+  hoistedMemoLocals = new Map;
   loweringMatchers = [];
   nillablePropNames = new Set;
   rootScopeNodes = new Set;
@@ -1024,9 +1042,12 @@ function forEachValueChild(n, visit) {
 // src/adapter/expr/url-builder.ts
 import {
   parseExpression,
-  stringifyParsedExpr
+  stringifyParsedExpr,
+  isValidHelperId
 } from "@barefootjs/jsx";
-var GO_HELPER_NAMES = { query: "bf_query" };
+function goHelperName(helper) {
+  return isValidHelperId(helper) ? `bf_${helper}` : null;
+}
 var BOOL_COMPARISON_OPS = new Set([
   "==",
   "===",
@@ -1069,7 +1090,7 @@ function lowerRegisteredCall(ctx, jsExpr, preParsed) {
   return null;
 }
 function renderLoweringNode(ctx, node) {
-  const helper = GO_HELPER_NAMES[node.helper];
+  const helper = goHelperName(node.helper);
   if (!helper)
     return null;
   const lowerExpr = (n) => ctx.convertExpressionToGo(stringifyParsedExpr(n), undefined, n);
@@ -1109,7 +1130,7 @@ function typeInfoToGo(ctx, typeInfo, defaultValue) {
     case "object":
       return "map[string]interface{}";
     case "interface":
-      if (typeInfo.raw && ctx.state.localTypeNames.has(typeInfo.raw)) {
+      if (typeInfo.raw && (ctx.state.localStructFields.has(typeInfo.raw) || ctx.state.localTypeAliases.has(typeInfo.raw))) {
         return typeInfo.raw;
       }
       if (typeInfo.raw) {
@@ -1142,7 +1163,7 @@ function tsTypeStringToGo(ctx, tsType) {
   const arrayMatch = t.match(/^Array<(.+)>$/);
   if (arrayMatch)
     return `[]${tsTypeStringToGo(ctx, arrayMatch[1])}`;
-  if (ctx.state.localTypeNames.has(t))
+  if (ctx.state.localStructFields.has(t) || ctx.state.localTypeAliases.has(t))
     return t;
   return "interface{}";
 }
@@ -1164,6 +1185,24 @@ function inferTypeFromValue(value) {
 }
 
 // src/adapter/value/parsed-literal-to-go.ts
+function structPropertyType(ctx, structGoType, key) {
+  const td = ctx.state.currentTypeDefinitions.find((t) => t.name === structGoType);
+  return td?.properties?.find((p) => p.name === key)?.type;
+}
+function bakeInlineObjectAsGoMap(ctx, expr) {
+  if (expr.kind !== "object-literal")
+    return null;
+  const entries = [];
+  for (const prop of expr.properties) {
+    if (prop.shorthand)
+      return null;
+    const go = prop.value.kind === "object-literal" ? bakeInlineObjectAsGoMap(ctx, prop.value) : parsedLiteralToGo(ctx, prop.value);
+    if (go === null)
+      return null;
+    entries.push(`${JSON.stringify(goFieldNameForKey(prop.key))}: ${go}`);
+  }
+  return `map[string]interface{}{${entries.join(", ")}}`;
+}
 function parsedLiteralToGo(ctx, expr, typeInfo) {
   if (expr.kind === "unary" && expr.op === "-" && expr.argument.kind === "literal" && expr.argument.literalType === "number") {
     return expr.argument.raw !== undefined ? `-${expr.argument.raw}` : null;
@@ -1204,9 +1243,16 @@ function parsedLiteralToGo(ctx, expr, typeInfo) {
       const goField = structFields.get(prop.key);
       if (!goField)
         return null;
-      if (prop.value.kind === "object-literal" || prop.value.kind === "array-literal")
-        return null;
-      const go = parsedLiteralToGo(ctx, prop.value);
+      const propType = structPropertyType(ctx, goType, prop.key);
+      let go;
+      if (prop.value.kind === "array-literal") {
+        go = parsedLiteralToGo(ctx, prop.value, propType);
+      } else if (prop.value.kind === "object-literal") {
+        const nestedGoType = propType ? typeInfoToGo(ctx, propType) : undefined;
+        go = nestedGoType && ctx.state.localStructFields.has(nestedGoType) ? parsedLiteralToGo(ctx, prop.value, propType) : bakeInlineObjectAsGoMap(ctx, prop.value);
+      } else {
+        go = parsedLiteralToGo(ctx, prop.value);
+      }
       if (go === null)
         return null;
       entries.push(`${goField}: ${go}`);
@@ -1317,8 +1363,17 @@ function getSignalInitialValueAsGo(ctx, initialValue, propsParams, propFallbackV
 }
 
 // src/adapter/memo/memo-type.ts
+import { asCallbackMethodCall } from "@barefootjs/jsx";
+function isListFilterMemo(memo) {
+  if (!memo.parsed)
+    return false;
+  const cb = asCallbackMethodCall(memo.parsed);
+  return cb !== null && cb.method === "filter";
+}
 function isBooleanMemo(ctx, memo, signals, propsParamMap) {
   const c = memo.computation;
+  if (isListFilterMemo(memo))
+    return false;
   if (isStringTernaryMemo(ctx, memo.parsed))
     return false;
   if (/(!==|===|!=(?!=)|==(?!=))/.test(c))
@@ -1609,6 +1664,14 @@ function computeObjectMemoInitialValue(ctx, memo) {
 	}`;
 }
 
+// src/adapter/memo/memo-compute.ts
+import {
+  asCallbackMethodCall as asCallbackMethodCall2,
+  freeVarsInBody as freeVarsInBody2,
+  materializeGetterCalls,
+  serializeParsedExpr as serializeParsedExpr2
+} from "@barefootjs/jsx";
+
 // src/adapter/memo/template-interp.ts
 import ts from "typescript";
 function computeTemplateLiteralMemoInitialValue(ctx, memo, propsParams) {
@@ -1749,8 +1812,49 @@ function propsAccessNameFromParsed(ctx, node) {
 
 // src/adapter/memo/memo-compute.ts
 var EMPTY_PROP_FALLBACK_VARS2 = new Map;
+function getterCallName(e) {
+  return e.kind === "call" && e.callee.kind === "identifier" && e.args.length === 0 ? e.callee.name : null;
+}
+function propsMemberName(e) {
+  return e.kind === "member" && !e.computed && e.object.kind === "identifier" && e.object.name === "props" ? e.property : null;
+}
+function matchFilterArmMemo(ctx, body, signals, propsParams) {
+  const cb = asCallbackMethodCall2(body);
+  if (!cb || cb.method !== "filter")
+    return null;
+  const propName = propsMemberName(cb.object);
+  const param = propName ? propsParams.find((p) => p.name === propName) : undefined;
+  if (!propName || !param)
+    return null;
+  const knownGetterNames = new Set(ctx.state.ssrSeedPlan.steps.filter((s) => s.kind !== "env-reader").map((s) => s.name));
+  const materialized = materializeGetterCalls(cb.arrow.body, knownGetterNames);
+  const predJSON = serializeParsedExpr2(materialized);
+  if (predJSON === null)
+    return null;
+  const paramName = cb.arrow.params[0] ?? "_";
+  const freeVars = freeVarsInBody2(materialized, new Set(cb.arrow.params));
+  return { propName, predJSON, paramName, freeVars };
+}
+function filterArmEarlierSiblingRefs(ctx, memo, signals, propsParams) {
+  if (!memo.parsed)
+    return [];
+  const match = matchFilterArmMemo(ctx, memo.parsed, signals, propsParams);
+  if (!match)
+    return [];
+  const memos = ctx.state.currentMemos ?? [];
+  const currentIndex = memos.findIndex((m) => m.name === memo.name);
+  if (currentIndex < 0)
+    return [];
+  const refs = [];
+  for (const name of match.freeVars) {
+    const idx = memos.findIndex((m) => m.name === name);
+    if (idx >= 0 && idx < currentIndex)
+      refs.push(name);
+  }
+  return refs;
+}
 function computeMemoInitialValue(ctx, memo, signals, propsParams, propFallbackVars = EMPTY_PROP_FALLBACK_VARS2, goType) {
-  const resolved = computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFallbackVars);
+  const resolved = computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFallbackVars, new Set([memo.name]));
   if (resolved !== null)
     return resolved;
   if (goType === "bool")
@@ -1762,15 +1866,79 @@ function computeMemoInitialValue(ctx, memo, signals, propsParams, propFallbackVa
   }
   return "0";
 }
-function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallbackVars) {
+function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallbackVars, currentMemoName, resolving = new Set) {
   const propRef = (propName) => {
     const hoisted = propFallbackVars.get(propName);
     if (hoisted)
       return hoisted.varName;
     return `in.${capitalizeFieldName(propName)}`;
   };
-  const getterCallName = (e) => e.kind === "call" && e.callee.kind === "identifier" && e.args.length === 0 ? e.callee.name : null;
-  const propsMemberName = (e) => e.kind === "member" && !e.computed && e.object.kind === "identifier" && e.object.name === "props" ? e.property : null;
+  const envGetKey = (e) => {
+    if (e.kind !== "call" || e.callee.kind !== "member" || e.callee.computed)
+      return null;
+    const recvName = getterCallName(e.callee.object);
+    if (recvName === null)
+      return null;
+    const reader = ctx.state.envSignalReadersByLocal.get(recvName);
+    if (!reader || !reader.methods.has(e.callee.property))
+      return null;
+    const arg = e.args[0];
+    if (!arg || arg.kind !== "literal" || arg.literalType !== "string")
+      return null;
+    return { key: String(arg.value), fieldName: capitalizeFieldName(reader.canonicalName) };
+  };
+  {
+    const m = envGetKey(body);
+    if (m !== null)
+      return `in.${m.fieldName}.Get(${JSON.stringify(m.key)})`;
+  }
+  if (body.kind === "logical" && (body.op === "??" || body.op === "||") && body.right.kind === "literal" && body.right.literalType === "string") {
+    const m = envGetKey(body.left);
+    if (m !== null) {
+      const def = JSON.stringify(String(body.right.value));
+      return `func() string { if v := in.${m.fieldName}.Get(${JSON.stringify(m.key)}); v != "" { return v }; return ${def} }()`;
+    }
+  }
+  {
+    const match = matchFilterArmMemo(ctx, body, signals, propsParams);
+    if (match) {
+      const { propName, predJSON, paramName, freeVars } = match;
+      const currentIndex = (ctx.state.currentMemos ?? []).findIndex((m) => m.name === currentMemoName);
+      const envEntries = [];
+      let unresolved = false;
+      for (const name of freeVars) {
+        let goExpr = null;
+        const siblingIndex = (ctx.state.currentMemos ?? []).findIndex((m) => m.name === name);
+        if (siblingIndex >= 0) {
+          const siblingMemo = ctx.state.currentMemos[siblingIndex];
+          const eligible = currentIndex >= 0 && siblingIndex < currentIndex && !resolving.has(siblingMemo.name);
+          if (eligible) {
+            const hoisted = ctx.state.hoistedMemoLocals.get(siblingMemo.name);
+            goExpr = hoisted ?? computeMemoInitialValueOrNull(ctx, siblingMemo, signals, propsParams, propFallbackVars, new Set([...resolving, siblingMemo.name]));
+          }
+        } else {
+          const sig = signals.find((s) => s.getter === name);
+          if (sig) {
+            goExpr = getSignalInitialValueAsGo(ctx, sig.initialValue, propsParams, propFallbackVars);
+          } else {
+            const p = propsParams.find((pp) => pp.name === name);
+            if (p)
+              goExpr = propRef(name);
+          }
+        }
+        if (goExpr === null) {
+          unresolved = true;
+          break;
+        }
+        envEntries.push(`${JSON.stringify(name)}: ${goExpr}`);
+      }
+      if (!unresolved) {
+        const itemsField = `in.${capitalizeFieldName(propName)}`;
+        const envMap = `map[string]any{${envEntries.join(", ")}}`;
+        return `bf.FilterEval(${itemsField}, "${escapeGoString(predJSON)}", ${JSON.stringify(paramName)}, ${envMap})`;
+      }
+    }
+  }
   if (body.kind === "binary" && ["===", "!==", "==", "!="].includes(body.op) && body.right.kind === "literal" && body.right.literalType === "string") {
     const depName = getterCallName(body.left);
     if (depName) {
@@ -1809,8 +1977,8 @@ function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallback
           condGo = getSignalInitialValueAsGo(ctx, condSignal.initialValue, propsParams, propFallbackVars);
         } else {
           const condMemo = (ctx.state.currentMemos ?? []).find((m) => m.name === condName);
-          if (condMemo) {
-            condGo = computeMemoInitialValueOrNull(ctx, condMemo, signals, propsParams, propFallbackVars);
+          if (condMemo && !resolving.has(condMemo.name)) {
+            condGo = computeMemoInitialValueOrNull(ctx, condMemo, signals, propsParams, propFallbackVars, new Set([...resolving, condMemo.name]));
           }
         }
         if (condGo === "true")
@@ -1884,17 +2052,17 @@ function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallback
   }
   return null;
 }
-function computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFallbackVars = EMPTY_PROP_FALLBACK_VARS2) {
+function computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFallbackVars = EMPTY_PROP_FALLBACK_VARS2, resolving = new Set) {
   const computation = memo.computation;
   const tmplMemo = computeTemplateLiteralMemoInitialValue(ctx, memo, propsParams);
   if (tmplMemo !== null)
     return tmplMemo;
   if (memo.parsed) {
-    const fromParsed = memoInitialFromParsedBody(ctx, memo.parsed, signals, propsParams, propFallbackVars);
+    const fromParsed = memoInitialFromParsedBody(ctx, memo.parsed, signals, propsParams, propFallbackVars, memo.name, resolving);
     if (fromParsed !== null)
       return fromParsed;
   }
-  const cmpTernary = computeComparisonTernaryGo(ctx, memo.parsed, signals, propsParams, propFallbackVars);
+  const cmpTernary = computeComparisonTernaryGo(ctx, memo.parsed, signals, propsParams, propFallbackVars, resolving);
   if (cmpTernary !== null)
     return cmpTernary;
   const blockReturn = resolveBlockBodyMemoModuleConst(ctx, memo, signals);
@@ -1906,20 +2074,22 @@ function computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFall
     return objMemo;
   return null;
 }
-function resolveGetterValueAsGo(ctx, name, signals, propsParams, propFallbackVars) {
+function resolveGetterValueAsGo(ctx, name, signals, propsParams, propFallbackVars, resolving = new Set) {
   const signal = signals.find((s) => s.getter === name);
   if (signal) {
     return getSignalInitialValueAsGo(ctx, signal.initialValue, propsParams, propFallbackVars);
   }
   const memo = (ctx.state.currentMemos ?? []).find((m) => m.name === name);
   if (memo) {
+    if (resolving.has(memo.name))
+      return null;
     const stripped = memo.computation.replace(/^\(\)\s*=>\s*/, "");
     const fb = ctx.extractPropFallback(stripped);
     if (fb && capitalizeFieldName(fb.propName) === capitalizeFieldName(memo.name)) {
       const field = `in.${capitalizeFieldName(fb.propName)}`;
       return `func() interface{} { v := interface{}(${field}); if v == nil || v == "" { return ${fb.goFallback} }; return v }()`;
     }
-    return computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFallbackVars);
+    return computeMemoInitialValueOrNull(ctx, memo, signals, propsParams, propFallbackVars, new Set([...resolving, memo.name]));
   }
   const param = propsParams.find((p) => p.name === name);
   if (param) {
@@ -1928,7 +2098,7 @@ function resolveGetterValueAsGo(ctx, name, signals, propsParams, propFallbackVar
   }
   return null;
 }
-function computeComparisonTernaryGo(ctx, parsed, signals, propsParams, propFallbackVars) {
+function computeComparisonTernaryGo(ctx, parsed, signals, propsParams, propFallbackVars, resolving = new Set) {
   if (!parsed || parsed.kind !== "conditional")
     return null;
   const cond = parsed.test;
@@ -1953,16 +2123,16 @@ function computeComparisonTernaryGo(ctx, parsed, signals, propsParams, propFallb
   const f = branch(parsed.alternate);
   if (t === null || f === null)
     return null;
-  const condGo = resolveComparisonOperandGo(ctx, cond.left, signals, propsParams, propFallbackVars);
+  const condGo = resolveComparisonOperandGo(ctx, cond.left, signals, propsParams, propFallbackVars, resolving);
   if (condGo === null)
     return null;
   const eqBranch = isEq ? t : f;
   const neBranch = isEq ? f : t;
   return `func() string { if ${condGo} == ${JSON.stringify(cond.right.value)} { return ${eqBranch} }; return ${neBranch} }()`;
 }
-function resolveComparisonOperandGo(ctx, node, signals, propsParams, propFallbackVars) {
+function resolveComparisonOperandGo(ctx, node, signals, propsParams, propFallbackVars, resolving = new Set) {
   if (node.kind === "call" && node.callee.kind === "identifier" && node.args.length === 0) {
-    return resolveGetterValueAsGo(ctx, node.callee.name, signals, propsParams, propFallbackVars);
+    return resolveGetterValueAsGo(ctx, node.callee.name, signals, propsParams, propFallbackVars, resolving);
   }
   if (node.kind === "logical" && node.op === "??" && node.right.kind === "literal" && node.right.literalType === "string") {
     const propName = propsAccessNameFromParsed2(ctx, node.left);
@@ -2320,8 +2490,10 @@ class GoTemplateAdapter extends BaseAdapter {
   inLoop = false;
   loopParamStack = [];
   loopScalarItemStack = [];
+  loopWrapperStack = [];
   loopVarRefCount = new Map;
   loopBindingStack = [];
+  loopRestExcludeStack = [];
   childComponentShapes = new Map;
   childContextConsumers = new Map;
   constructor(options = {}) {
@@ -2341,7 +2513,18 @@ class GoTemplateAdapter extends BaseAdapter {
     this.state.currentMemos = ir.metadata.memos ?? [];
     this.state.currentTypeDefinitions = ir.metadata.typeDefinitions ?? [];
     this.state.contextConsumers = collectContextConsumers(ir.metadata);
-    this.state.searchParamsLocals = searchParamsLocalNames(ir.metadata);
+    this.state.ssrSeedPlan = ir.metadata.ssrSeedPlan ?? computeSsrSeedPlan(ir.metadata);
+    this.state.envSignalReadersByLocal = new Map;
+    this.state.searchParamsLocals = new Set;
+    for (const step of this.state.ssrSeedPlan.steps) {
+      if (step.kind !== "env-reader")
+        continue;
+      const reader = envSignalReaderFor(step.reader.key);
+      if (reader)
+        this.state.envSignalReadersByLocal.set(step.name, reader);
+      if (step.reader.key === "search")
+        this.state.searchParamsLocals.add(step.name);
+    }
     this.state.loweringMatchers = prepareLoweringMatchers(ir.metadata);
     augmentInheritedPropAccesses(ir);
   }
@@ -2503,11 +2686,22 @@ ${scriptRegistrations}${templateBody}
   contextFieldName(c) {
     return capitalizeFieldName(c.localName);
   }
+  isMapRootedContextChain(node) {
+    if (node.kind === "identifier") {
+      return this.state.contextConsumers.some((c) => c.localName === node.name && c.defaultKind === "object");
+    }
+    if (node.kind === "member" && !node.computed) {
+      return this.isMapRootedContextChain(node.object);
+    }
+    return false;
+  }
   contextConsumerGoType(c) {
     if (typeof c.defaultValue === "number")
       return "int";
     if (typeof c.defaultValue === "boolean")
       return "bool";
+    if (c.defaultKind === "object")
+      return "map[string]interface{}";
     return "string";
   }
   contextConsumerGoDefault(c) {
@@ -2517,6 +2711,8 @@ ${scriptRegistrations}${templateBody}
       return String(c.defaultValue);
     if (typeof c.defaultValue === "string")
       return `"${escapeGoString(c.defaultValue)}"`;
+    if (c.defaultKind === "object")
+      return "map[string]interface{}{}";
     return '""';
   }
   nonCollidingContextConsumers(taken) {
@@ -2563,12 +2759,15 @@ ${goFields.join(`
   }
   structFieldsFor(td) {
     const fields = [];
+    const seenGoNames = new Set;
     for (const prop of td.properties ?? []) {
-      if (!GO_IDENTIFIER.test(prop.name))
+      const goName = goFieldNameForKey(prop.name);
+      if (seenGoNames.has(goName))
         continue;
+      seenGoNames.add(goName);
       fields.push({
         tsName: prop.name,
-        goName: capitalizeFieldName(prop.name),
+        goName,
         goType: typeInfoToGo(this.emitCtx, prop.type)
       });
     }
@@ -2796,10 +2995,10 @@ ${goFields.join(`
     }
     return "interface{}";
   }
-  collectBodyChildInstances(bodyChildren) {
+  collectBodyChildInstances(bodyChildren, propsParams = []) {
     const result = [];
     for (const child of bodyChildren) {
-      this.collectStaticChildInstancesRecursive(child, result, false, new Map);
+      this.collectStaticChildInstancesRecursive(child, result, false, new Map, propsParams);
     }
     return result;
   }
@@ -2845,6 +3044,28 @@ ${goFields.join(`
     if (propFallbackVars.size > 0)
       lines.push("");
     this.emitDynamicBodyWrappers(lines, ir, componentName, dynamicWithBody, propFallbackVars, emittedWrapperVars);
+    const memoPropsParamMap = new Map(ir.metadata.propsParams.map((p) => [p.name, p]));
+    this.state.hoistedMemoLocals = new Map;
+    const hoistNames = new Set;
+    for (const memo of ir.metadata.memos) {
+      for (const name of filterArmEarlierSiblingRefs(this.emitCtx, memo, ir.metadata.signals, ir.metadata.propsParams)) {
+        hoistNames.add(name);
+      }
+    }
+    if (hoistNames.size > 0) {
+      for (const memo of ir.metadata.memos) {
+        if (!hoistNames.has(memo.name))
+          continue;
+        const goType = this.inferMemoType(memo, ir.metadata.signals, memoPropsParamMap);
+        const value = computeMemoInitialValue(this.emitCtx, memo, ir.metadata.signals, ir.metadata.propsParams, propFallbackVars, goType);
+        let localName = `memo${capitalizeFieldName(memo.name)}`;
+        while (GO_KEYWORDS.has(localName))
+          localName += "_";
+        lines.push(`	var ${localName} ${goType} = ${value}`);
+        this.state.hoistedMemoLocals.set(memo.name, localName);
+      }
+      lines.push("");
+    }
     lines.push(`	return ${propsTypeName}{`);
     lines.push("\t\tScopeID: scopeID,");
     lines.push("\t\tBfParent: in.BfParent,");
@@ -2918,11 +3139,15 @@ ${goFields.join(`
         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 = capitalizeFieldName(memo.name);
       if (propFieldNames.has(fieldName))
         continue;
+      const hoistedLocal = this.state.hoistedMemoLocals.get(memo.name);
+      if (hoistedLocal) {
+        lines.push(`		${fieldName}: ${hoistedLocal},`);
+        continue;
+      }
       const goType = this.inferMemoType(memo, ir.metadata.signals, memoPropsParamMap);
       const memoValue = computeMemoInitialValue(this.emitCtx, memo, ir.metadata.signals, ir.metadata.propsParams, propFallbackVars, goType);
       lines.push(`		${fieldName}: ${memoValue},`);
@@ -2943,7 +3168,7 @@ ${goFields.join(`
     for (const c of this.nonCollidingContextConsumers(takenInit)) {
       const field = this.contextFieldName(c);
       const def = this.contextConsumerGoDefault(c);
-      const defaulted = c.defaultValue === null || def === '""' || def === "0" || def === "false" ? `in.${field}` : applyGoFallback(`in.${field}`, def);
+      const defaulted = c.defaultValue === null || def === '""' || def === "0" || def === "false" || def === "map[string]interface{}{}" ? `in.${field}` : applyGoFallback(`in.${field}`, def);
       lines.push(`		${field}: ${defaulted},`);
     }
     this.emitStaticChildInstances(lines, ir);
@@ -2952,7 +3177,7 @@ ${goFields.join(`
     lines.push("}");
   }
   emitStaticChildInstances(lines, ir) {
-    const staticChildren = this.collectStaticChildInstances(ir.root);
+    const staticChildren = this.collectStaticChildInstances(ir.root, ir.metadata.propsParams);
     for (const child of staticChildren) {
       lines.push(`		${child.fieldName}: New${child.name}Props(${child.name}Input{`);
       lines.push(`			ScopeID: scopeID + "_${child.slotId}",`);
@@ -3084,7 +3309,7 @@ ${goFields.join(`
       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);
+      const bodyChildInstances = this.collectBodyChildInstances(nested.bodyChildren, ir.metadata.propsParams);
       for (const child of bodyChildInstances) {
         const childVar = `child_${child.fieldName}`;
         lines.push(`	${childVar} := New${child.name}Props(${child.name}Input{`);
@@ -3161,7 +3386,7 @@ ${goFields.join(`
       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);
+      const bodyChildInstances = this.collectBodyChildInstances(nested.bodyChildren, ir.metadata.propsParams);
       for (const child of bodyChildInstances) {
         const childVar = `child_${child.fieldName}`;
         lines.push(`	${childVar} := New${child.name}Props(${child.name}Input{`);
@@ -3401,7 +3626,7 @@ ${goFields.join(`
         lines.push(`	${nested.name}s []${elemType} \`json:"${jsonTag}"\``);
       }
     }
-    const staticChildren = this.collectStaticChildInstances(ir.root);
+    const staticChildren = this.collectStaticChildInstances(ir.root, ir.metadata.propsParams);
     for (const child of staticChildren) {
       lines.push(`	${child.fieldName} ${child.name}Props \`json:"-"\``);
     }
@@ -3413,9 +3638,9 @@ ${goFields.join(`
   toJsonTag(name) {
     return name.charAt(0).toLowerCase() + name.slice(1);
   }
-  collectStaticChildInstances(node) {
+  collectStaticChildInstances(node, propsParams = []) {
     const result = [];
-    this.collectStaticChildInstancesRecursive(node, result, false, new Map);
+    this.collectStaticChildInstancesRecursive(node, result, false, new Map, propsParams);
     return result;
   }
   extractTextChildren(children) {
@@ -3460,12 +3685,12 @@ ${goFields.join(`
       return null;
     return withSentinel.split(GoTemplateAdapter.SCOPE_SENTINEL).map((seg) => JSON.stringify(seg)).join(" + scopeID + ");
   }
-  collectStaticChildInstancesRecursive(node, result, inLoop, providerCtx) {
+  collectStaticChildInstancesRecursive(node, result, inLoop, providerCtx, propsParams = []) {
     if (node.type === "component") {
       const comp = node;
       if (comp.dynamicTag) {
         for (const child of comp.children) {
-          this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx);
+          this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx, propsParams);
         }
         return;
       }
@@ -3483,69 +3708,111 @@ ${goFields.join(`
           contextBindings: providerCtx.size > 0 ? providerCtx : undefined
         });
         for (const child of effectiveChildren) {
-          this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx);
+          this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx, propsParams);
         }
       }
       if (comp.name === "Portal" && comp.children) {
         for (const child of comp.children) {
-          this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx);
+          this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx, propsParams);
         }
       }
     } else if (node.type === "loop") {
       const loop = node;
       for (const child of loop.children) {
-        this.collectStaticChildInstancesRecursive(child, result, true, providerCtx);
+        this.collectStaticChildInstancesRecursive(child, result, inLoop || !!loop.childComponent, providerCtx, propsParams);
       }
     } else if (node.type === "element") {
       const element = node;
       for (const child of element.children) {
-        this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx);
+        this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx, propsParams);
       }
     } else if (node.type === "fragment") {
       const fragment = node;
       for (const child of fragment.children) {
-        this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx);
+        this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx, propsParams);
       }
     } else if (node.type === "conditional") {
       const cond = node;
-      this.collectStaticChildInstancesRecursive(cond.whenTrue, result, inLoop, providerCtx);
+      this.collectStaticChildInstancesRecursive(cond.whenTrue, result, inLoop, providerCtx, propsParams);
       if (cond.whenFalse) {
-        this.collectStaticChildInstancesRecursive(cond.whenFalse, result, inLoop, providerCtx);
+        this.collectStaticChildInstancesRecursive(cond.whenFalse, result, inLoop, providerCtx, propsParams);
       }
     } else if (node.type === "if-statement") {
       const stmt = node;
-      this.collectStaticChildInstancesRecursive(stmt.consequent, result, inLoop, providerCtx);
+      this.collectStaticChildInstancesRecursive(stmt.consequent, result, inLoop, providerCtx, propsParams);
       if (stmt.alternate) {
-        this.collectStaticChildInstancesRecursive(stmt.alternate, result, inLoop, providerCtx);
+        this.collectStaticChildInstancesRecursive(stmt.alternate, result, inLoop, providerCtx, propsParams);
       }
     } else if (node.type === "provider") {
       const p = node;
-      const childCtx = this.extendProviderContext(providerCtx, p);
+      const childCtx = this.extendProviderContext(providerCtx, p, propsParams);
       for (const child of p.children) {
-        this.collectStaticChildInstancesRecursive(child, result, inLoop, childCtx);
+        this.collectStaticChildInstancesRecursive(child, result, inLoop, childCtx, propsParams);
       }
     } else if (node.type === "async") {
       const a = node;
-      this.collectStaticChildInstancesRecursive(a.fallback, result, inLoop, providerCtx);
+      this.collectStaticChildInstancesRecursive(a.fallback, result, inLoop, providerCtx, propsParams);
       for (const child of a.children) {
-        this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx);
+        this.collectStaticChildInstancesRecursive(child, result, inLoop, providerCtx, propsParams);
       }
     }
   }
-  extendProviderContext(current, p) {
+  extendProviderContext(current, p, propsParams) {
     const v = p.valueProp?.value;
-    if (!v || v.kind !== "literal")
+    if (!v)
       return current;
-    let goLit = null;
-    if (typeof v.value === "string")
-      goLit = `"${escapeGoString(v.value)}"`;
-    else if (typeof v.value === "number" || typeof v.value === "boolean")
-      goLit = String(v.value);
-    if (goLit === null)
-      return current;
-    const next = new Map(current);
-    next.set(p.contextName, goLit);
-    return next;
+    if (v.kind === "literal") {
+      let goLit = null;
+      if (typeof v.value === "string")
+        goLit = `"${escapeGoString(v.value)}"`;
+      else if (typeof v.value === "number" || typeof v.value === "boolean")
+        goLit = String(v.value);
+      if (goLit === null)
+        return current;
+      const next = new Map(current);
+      next.set(p.contextName, goLit);
+      return next;
+    }
+    if (v.kind === "expression" && v.parsed) {
+      const goMap = this.providerObjectValueToGoMap(v.parsed, propsParams);
+      if (goMap !== null) {
+        const next = new Map(current);
+        next.set(p.contextName, goMap);
+        return next;
+      }
+    }
+    return current;
+  }
+  providerObjectValueToGoMap(parsed, propsParams) {
+    if (parsed.kind !== "object-literal")
+      return null;
+    const entries = [];
+    for (const prop of parsed.properties) {
+      if (prop.shorthand)
+        return null;
+      const goVal = this.lowerProviderMapMemberValue(prop.value, propsParams);
+      if (goVal === null)
+        return null;
+      entries.push(`${JSON.stringify(prop.key)}: ${goVal}`);
+    }
+    if (entries.length === 0)
+      return null;
+    return `map[string]interface{}{${entries.join(", ")}}`;
+  }
+  lowerProviderMapMemberValue(node, propsParams) {
+    if (node.kind === "object-literal")
+      return objectLiteralToGoMap(this.emitCtx, node);
+    const literal = parsedLiteralToGo(this.emitCtx, node);
+    if (literal !== null)
+      return literal;
+    if (node.kind === "logical" && node.op === "??" && node.right.kind === "object-literal" && node.right.properties.length === 0 && node.left.kind === "member" && !node.left.computed && node.left.object.kind === "identifier" && node.left.object.name === this.state.propsObjectName) {
+      const propName = node.left.property;
+      if (propsParams.some((param) => param.name === propName)) {
+        const fieldRef = `in.${capitalizeFieldName(propName)}`;
+        return `func() map[string]interface{} { ` + `if m := bf.AsMap(${fieldRef}); m != nil { return m }; ` + `return map[string]interface{}{} }()`;
+      }
+    }
+    return null;
   }
   templatePartsToGoCode(parts, propsParams) {
     const segments = [];
@@ -3611,12 +3878,14 @@ ${goFields.join(`
       }
       const memo = memos.find((m) => m.name === getterName);
       if (memo) {
-        return computeMemoInitialValueOrNull(this.emitCtx, memo, signals, propsParams);
+        return computeMemoInitialValueOrNull(this.emitCtx, memo, signals, propsParams, undefined, new Set([memo.name]));
       }
     }
     return null;
   }
   inferMemoType(memo, signals, propsParamMap) {
+    if (isListFilterMemo(memo))
+      return "[]any";
     if (memo.bodyIsTemplateLiteral)
       return "string";
     if (memo.computation.includes("*") || memo.computation.includes("/") || memo.computation.includes("+") || memo.computation.includes("-")) {
@@ -4013,15 +4282,19 @@ ${goFields.join(`
     if (objHO && (objHO.method === "find" || objHO.method === "findLast")) {
       const findResult = this.renderHigherOrderExpr(objHO, emit);
       if (findResult) {
-        return `{{with ${findResult}}}{{.${capitalizeFieldName(property)}}}{{end}}`;
+        return `{{with ${findResult}}}{{.${goFieldNameForKey(property)}}}{{end}}`;
       }
-      const templateBlock = this.renderFindTemplateBlock(objHO, emit, capitalizeFieldName(property));
+      const templateBlock = this.renderFindTemplateBlock(objHO, emit, goFieldNameForKey(property));
       if (templateBlock)
         return templateBlock;
     }
     if (object.kind === "identifier" && this.state.propsObjectName && object.name === this.state.propsObjectName) {
       return this.rootFieldRef(property);
     }
+    if (this.isMapRootedContextChain(object)) {
+      const objGo = emit(object);
+      return `bf_get ${wrapIfMultiToken(objGo)} ${JSON.stringify(property)}`;
+    }
     if (object.kind === "identifier") {
       const staticValue = this.resolveStaticRecordLiteralIndex(`${object.name}.${property}`);
       if (staticValue !== null)
@@ -4029,12 +4302,12 @@ ${goFields.join(`
     }
     const currentLoopParam = this.loopParamStack[this.loopParamStack.length - 1];
     if (object.kind === "identifier" && currentLoopParam && object.name === currentLoopParam) {
-      return `.${capitalizeFieldName(property)}`;
+      return `.${goFieldNameForKey(property)}`;
     }
     const obj = emit(object);
     if (property === "length")
       return `len ${obj}`;
-    return `${obj}.${capitalizeFieldName(property)}`;
+    return `${obj}.${goFieldNameForKey(property)}`;
   }
   indexAccess(object, index, emit) {
     return `index ${wrapIfMultiToken(emit(object))} ${wrapIfMultiToken(emit(index))}`;
@@ -4126,7 +4399,16 @@ ${goFields.join(`
     return `bf_arr ${parts.join(" ")}`;
   }
   objectLiteral(_properties, raw, _emit) {
-    return this.unsupported(raw, "object literal");
+    this.state.errors.push({
+      code: "BF101",
+      severity: "error",
+      message: `Expression not supported: ${raw}`,
+      loc: this.makeLoc(),
+      suggestion: {
+        message: `Go templates have no object/map literal syntax, so the \`?? {}\` fallback can't render server-side. ${GO_REMEDIATION_OPTIONS}`
+      }
+    });
+    return `""`;
   }
   static PREDICATE_METHODS = new Set([
     "filter",
@@ -4138,7 +4420,7 @@ ${goFields.join(`
     "some"
   ]);
   higherOrderShapeOf(node) {
-    const cb = asCallbackMethodCall(node);
+    const cb = asCallbackMethodCall3(node);
     if (!cb)
       return null;
     if (!GoTemplateAdapter.PREDICATE_METHODS.has(cb.method))
@@ -4213,6 +4495,12 @@ ${goFields.join(`
         return evalForm;
       return this.pushCallbackBF101(method, true);
     }
+    if (method === "map") {
+      const evalForm = emitMapEval(recv, body, params[0] ?? "_", emit);
+      if (evalForm !== null)
+        return evalForm;
+      return this.pushCallbackBF101(method, true);
+    }
     return this.pushCallbackBF101(method, true);
   }
   arrayMethod(method, object, args, emit) {
@@ -4333,6 +4621,9 @@ ${goFields.join(`
     }
   }
   flatMethod(object, depth, emit) {
+    if (typeof depth === "object") {
+      return `bf_flat_dynamic ${wrapIfMultiToken(emit(object))} ${wrapIfMultiToken(emit(depth.expr))}`;
+    }
     const d = depth === "infinity" ? -1 : depth;
     return `bf_flat ${wrapIfMultiToken(emit(object))} ${d}`;
   }
@@ -4566,6 +4857,9 @@ ${goFields.join(`
         if (expr.callee.kind === "identifier" && expr.args.length === 0) {
           return `$.${capitalizeFieldName(expr.callee.name)}`;
         }
+        if (asCallbackMethodCall3(expr) !== null) {
+          return this.refuseFilterExprNode(expr);
+        }
         const result = this.renderFilterExpr(expr.callee, param, localVarMap);
         if (this.filterExprUnsupported)
           return "false";
@@ -4630,21 +4924,23 @@ ${goFields.join(`
         }
         return `or (${left}) (${right})`;
       }
-      default: {
-        this.filterExprUnsupported = true;
-        this.state.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";
-      }
+      default:
+        return this.refuseFilterExprNode(expr);
     }
   }
+  refuseFilterExprNode(expr) {
+    this.filterExprUnsupported = true;
+    this.state.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":
@@ -4898,7 +5194,7 @@ ${goFields.join(`
           });
           return plain("false");
         }
-        if (asCallbackMethodCall(expr)) {
+        if (asCallbackMethodCall3(expr)) {
           const rendered = this.renderParsedExpr(expr);
           const split = this.splitPreamble(rendered);
           if (split)
@@ -5026,23 +5322,44 @@ ${goFields.join(`
         return plain(expr.raw);
     }
   }
+  buildSegmentAccessor(base, segments) {
+    let acc = base;
+    for (const seg of segments) {
+      acc = seg.kind === "field" ? `${acc}.${goFieldNameForKey(seg.key)}` : `(index ${acc} ${seg.index})`;
+    }
+    return acc;
+  }
   buildDestructureBindingMap(loop, rangeVar) {
-    const m = new Map;
+    const bindings = new Map;
+    const restExcludes = new Map;
+    const base = `$${rangeVar}`;
     for (const b of loop.paramBindings ?? []) {
-      if (b.rest) {
-        m.set(b.name, `$${rangeVar}`);
+      const parent = this.buildSegmentAccessor(base, b.segments ?? []);
+      if (!b.rest) {
+        bindings.set(b.name, parent);
+      } else if (b.rest.kind === "array") {
+        bindings.set(b.name, `(bf_slice ${parent} ${b.rest.from})`);
       } else {
-        m.set(b.name, `$${rangeVar}.${capitalizeFieldName(b.path.slice(1))}`);
+        bindings.set(b.name, parent);
+        restExcludes.set(b.name, { parent, excludeKeys: b.rest.exclude.map((k) => k.key) });
       }
     }
-    return m;
+    return { bindings, restExcludes };
+  }
+  lookupRestExclude(name) {
+    for (let i = this.loopRestExcludeStack.length - 1;i >= 0; i--) {
+      const info = this.loopRestExcludeStack[i].get(name);
+      if (info)
+        return info;
+    }
+    return;
   }
   renderLoop(loop) {
     if (loop.clientOnly) {
       return `{{bfComment "loop:${loop.markerId}"}}{{bfComment "/loop:${loop.markerId}"}}`;
     }
     const destructure = !!(loop.paramBindings && loop.paramBindings.length > 0);
-    const supportableDestructure = destructure && isLowerableObjectRestDestructure(loop);
+    const supportableDestructure = destructure && isLowerableLoopDestructure(loop);
     if (destructure && !supportableDestructure) {
       this.state.errors.push({
         code: "BF104",
@@ -5057,6 +5374,21 @@ ${goFields.join(`
         }
       });
     }
+    const arrayName = loop.array.trim();
+    if (/^[A-Za-z_$][\w$]*$/.test(arrayName)) {
+      const arrayConst = this.state.localConstants.find((c) => c.name === arrayName);
+      if (arrayConst && !arrayConst.isModule && arrayConst.parsed && !this.isStringExpr(arrayConst.parsed, new Set)) {
+        this.state.errors.push({
+          code: "BF101",
+          severity: "error",
+          message: `Loop array \`${arrayName}\` is a local computed value (\`${arrayConst.value}\`) that the Go template adapter cannot bind as a template variable — only a string-derived local resolves to a generated struct field.`,
+          loc: loop.loc ?? this.makeLoc(),
+          suggestion: {
+            message: "Pre-compute the array server-side and pass it as a prop, or mark the loop position as @client-only so it runs in JS on the client."
+          }
+        });
+      }
+    }
     let goArray = this.convertExpressionToGo(loop.array);
     const param = loop.param;
     let index = loop.index || "_";
@@ -5066,15 +5398,16 @@ ${goFields.join(`
       rangeIndex = param;
       rangeValue = "_";
     }
-    const childComponent = this.findChildComponent(loop.children);
-    if (childComponent) {
-      goArray = `.${childComponent.name}s`;
+    if (loop.childComponent) {
+      goArray = `.${loop.childComponent.name}s`;
     }
     this.inLoop = true;
     const addedLoopVars = [];
     let pushedBindingMap = false;
     if (supportableDestructure) {
-      this.loopBindingStack.push(this.buildDestructureBindingMap(loop, rangeValue));
+      const built = this.buildDestructureBindingMap(loop, rangeValue);
+      this.loopBindingStack.push(built.bindings);
+      this.loopRestExcludeStack.push(built.restExcludes);
       pushedBindingMap = true;
       this.loopParamStack.push("");
       if (rangeIndex !== "_") {
@@ -5093,7 +5426,9 @@ ${goFields.join(`
       }
     }
     this.loopScalarItemStack.push(this.scalarLiteralLoopGoType(loop.arrayParsed, loop.itemType) !== null);
+    this.loopWrapperStack.push(!!loop.childComponent);
     const children = this.renderChildren(loop.children);
+    this.loopWrapperStack.pop();
     this.loopScalarItemStack.pop();
     const itemMarker = this.loopItemMarker(loop);
     for (const v of addedLoopVars) {
@@ -5104,8 +5439,10 @@ ${goFields.join(`
         this.loopVarRefCount.set(v, rc);
     }
     this.loopParamStack.pop();
-    if (pushedBindingMap)
+    if (pushedBindingMap) {
       this.loopBindingStack.pop();
+      this.loopRestExcludeStack.pop();
+    }
     this.inLoop = false;
     if (loop.sortComparator) {
       const sortEmit = (e) => this.renderParsedExpr(e);
@@ -5134,24 +5471,6 @@ ${goFields.join(`
     }
     return "";
   }
-  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;
-  }
   queueDynamicChildrenDefine(comp) {
     const effectiveChildren = comp.children.length > 0 ? comp.children : this.jsxChildrenPropNodes(comp.props);
     if (effectiveChildren.length === 0)
@@ -5199,7 +5518,7 @@ ${goFields.join(`
       return this.renderChildren(comp.children);
     }
     let templateCall;
-    if (this.inLoop) {
+    if (this.inLoop && (this.loopWrapperStack[this.loopWrapperStack.length - 1] ?? false)) {
       const loopBodyDefine = this.queueLoopBodyChildrenDefine(comp);
       if (loopBodyDefine) {
         const bodyData = this.loopScalarItemStack[this.loopScalarItemStack.length - 1] ? ".BfLoopItem" : ".";
@@ -5207,6 +5526,12 @@ ${goFields.join(`
       } else {
         templateCall = `{{template "${comp.name}" .}}`;
       }
+    } else if (this.inLoop && comp.slotId) {
+      const suffix = slotIdToFieldSuffix(comp.slotId);
+      const loopBodyDefine = this.queueLoopBodyChildrenDefine(comp);
+      templateCall = loopBodyDefine ? `{{template "${comp.name}" (bf_with_children $.${comp.name}${suffix} (bf_tmpl "${loopBodyDefine}" .))}}` : `{{template "${comp.name}" $.${comp.name}${suffix}}}`;
+    } else if (this.inLoop) {
+      templateCall = `{{template "${comp.name}" .}}`;
     } else if (comp.slotId) {
       const suffix = slotIdToFieldSuffix(comp.slotId);
       const childrenDefine = this.queueDynamicChildrenDefine(comp);
@@ -5302,6 +5627,12 @@ ${children}`;
         if (currentLoopParam && trimmed === currentLoopParam) {
           return `{{bf_spread_attrs .}}`;
         }
+        const restInfo = this.lookupRestExclude(trimmed);
+        if (restInfo) {
+          const excludeArgs = restInfo.excludeKeys.map((k) => JSON.stringify(k)).join(" ");
+          const omitArgs = excludeArgs ? `${restInfo.parent} ${excludeArgs}` : restInfo.parent;
+          return `{{bf_spread_attrs (bf_omit ${omitArgs})}}`;
+        }
         const goExpr = this.convertExpressionToGo(value.expr);
         return `{{bf_spread_attrs ${goExpr}}}`;
       }