@barefootjs/go-template 0.17.1 → 0.18.0

package/dist/adapter/index.js

@@ -38,7 +38,7 @@ import {
   emitAttrValue,
   augmentInheritedPropAccesses,
   collectContextConsumers,
-  isLowerableObjectRestDestructure,
+  isLowerableLoopDestructure,
   collectModuleStringConsts as collectModuleStringConstsShared,
   prepareLoweringMatchers,
   envSignalReaderFor,
@@ -123,6 +123,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+)$/);
@@ -695,9 +702,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([
   "==",
   "===",
@@ -740,7 +750,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);
@@ -780,7 +790,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) {
@@ -813,7 +823,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{}";
 }
@@ -835,6 +845,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;
@@ -875,9 +903,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}`);
@@ -2115,8 +2150,10 @@ class GoTemplateAdapter extends BaseAdapter {
   inLoop = false;
   loopParamStack = [];
   loopScalarItemStack = [];
+  loopWrapperStack = [];
   loopVarRefCount = new Map;
   loopBindingStack = [];
+  loopRestExcludeStack = [];
   childComponentShapes = new Map;
   childContextConsumers = new Map;
   constructor(options = {}) {
@@ -2309,11 +2346,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) {
@@ -2323,6 +2371,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) {
@@ -2369,12 +2419,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)
       });
     }
@@ -2602,10 +2655,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;
   }
@@ -2775,7 +2828,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);
@@ -2784,7 +2837,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}",`);
@@ -2916,7 +2969,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{`);
@@ -2993,7 +3046,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{`);
@@ -3233,7 +3286,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:"-"\``);
     }
@@ -3245,9 +3298,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) {
@@ -3292,12 +3345,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;
       }
@@ -3315,69 +3368,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")
-      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)
+    if (!v)
       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 = [];
@@ -3847,15 +3942,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)
@@ -3863,12 +3962,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))}`;
@@ -3960,7 +4059,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",
@@ -4173,6 +4281,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}`;
   }
@@ -4871,23 +4982,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",
@@ -4902,6 +5034,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 || "_";
@@ -4911,15 +5058,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 !== "_") {
@@ -4938,7 +5086,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) {
@@ -4949,8 +5099,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);
@@ -4979,24 +5131,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)
@@ -5044,7 +5178,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" : ".";
@@ -5052,6 +5186,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);
@@ -5147,6 +5287,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}}}`;
       }

package/dist/adapter/lib/go-naming.d.ts

@@ -21,6 +21,29 @@ export declare const GO_KEYWORDS: Set<string>;
 export declare function capitalize(s: string): string;
 /** Capitalise a JSX prop / field name to its exported Go struct field name. */
 export declare function capitalizeFieldName(name: string): string;
+/**
+ * Resolve ANY source property key — identifier or not (`data-priority`,
+ * `aria-label`, a numeric key) — to a valid Go struct field name. Splits on
+ * runs of characters that are invalid in a Go identifier (underscores are
+ * VALID and preserved, so a snake_case key round-trips to the exact same
+ * name `capitalizeFieldName` alone has always produced — `foo_bar` →
+ * `Foo_bar`, never `FooBar`; renaming it would break both existing member
+ * emission and consumers' hand-written constructors against generated
+ * types) and PascalCases each segment through `capitalizeFieldName`, so a
+ * hyphenated key gets a real field instead of being silently dropped
+ * (`data-priority` → `DataPriority`). A result that would start with a
+ * digit (numeric key `0`) is prefixed with `Field` (`Field0`), and a key
+ * with no usable characters at all falls back to `Field` — both keep the
+ * emitted struct compiling (not expected from real TS property names, but
+ * keeps the function total).
+ *
+ * Single source of truth for the source-key → Go-name mapping: used for
+ * struct-field generation (#2087 Phase B — `structFieldsFor`), inline-map
+ * baking (`bakeInlineObjectAsGoMap`), and the `member()` dot-access
+ * emitter, so the baked side and the accessor side can never disagree
+ * (PR #2089 review).
+ */
+export declare function goFieldNameForKey(key: string): string;
 /**
  * Convert a slot ID (e.g., 's6') to a Go struct field suffix (e.g., 'Slot6').
  * Keeps field names human-readable regardless of the internal slot ID format.

package/dist/adapter/lib/go-naming.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"go-naming.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/go-naming.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,2DAA2D;AAC3D,eAAO,MAAM,aAAa,QAA6B,CAAA;AAEvD,iHAAiH;AACjH,eAAO,MAAM,cAAc,aAIzB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW,aAKtB,CAAA;AAEF;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAM5C;AAED,+EAA+E;AAC/E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOxD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAS1D;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAQtG"}
+{"version":3,"file":"go-naming.d.ts","sourceRoot":"","sources":["../../../src/adapter/lib/go-naming.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,2DAA2D;AAC3D,eAAO,MAAM,aAAa,QAA6B,CAAA;AAEvD,iHAAiH;AACjH,eAAO,MAAM,cAAc,aAIzB,CAAA;AAEF;;;GAGG;AACH,eAAO,MAAM,WAAW,aAKtB,CAAA;AAEF;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAM5C;AAED,+EAA+E;AAC/E,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOxD;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAKrD;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAS1D;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,IAAI,CAQtG"}

package/dist/adapter/type/type-codegen.d.ts

@@ -4,7 +4,11 @@
  * Free functions over a {@link GoEmitContext}. They resolve a prop/signal/const's
  * type (`TypeInfo`, a raw type string, or — as a last resort — an inferred shape
  * from a literal value) into the Go type used for its struct field. They read
- * only `state.localTypeNames`; `inferTypeFromValue` is fully pure.
+ * `state.localStructFields` / `state.localTypeAliases` (an ACTUAL Go-backed
+ * local type — a generated struct or a string-union alias) rather than the
+ * broader `state.localTypeNames` (every type definition, including a tuple
+ * alias no struct was ever emitted for — #2087); `inferTypeFromValue` is fully
+ * pure.
  */
 import type { TypeInfo } from '@barefootjs/jsx';
 import type { GoEmitContext } from '../emit-context.ts';