@barefootjs/go-template 0.18.4 → 0.18.7

package/dist/index.js

@@ -25,7 +25,7 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
 import {
   BaseAdapter,
   isBooleanAttr,
-  parseExpression as parseExpression3,
+  parseExpression as parseExpression4,
   stringifyParsedExpr as stringifyParsedExpr2,
   parseStyleObjectEntries,
   isSupported,
@@ -42,10 +42,17 @@ import {
   collectModuleStringConsts as collectModuleStringConstsShared,
   prepareLoweringMatchers,
   envSignalReaderFor,
-  computeSsrSeedPlan
+  computeSsrSeedPlan,
+  isStringConcatBinary,
+  isDangerousInnerHtmlAttr,
+  resolveDangerousInnerHtml,
+  dangerousInnerHtmlMetacharViolation,
+  dangerousInnerHtmlDiagnostic,
+  collectLoopBoundNames as collectLoopBoundNames2,
+  evaluateStaticLiteral as evaluateStaticLiteral3
 } from "@barefootjs/jsx";
 import { findInterpolationEnd } from "@barefootjs/jsx/scanner";
-import { BF_REGION } from "@barefootjs/shared";
+import { BF_REGION, escapeHtml } from "@barefootjs/shared";
 
 // src/adapter/lib/go-naming.ts
 var GO_IDENTIFIER = /^[A-Za-z_][A-Za-z0-9_]*$/;
@@ -332,6 +339,7 @@ var GO_TEMPLATE_PRIMITIVES = {
   "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.abs": { arity: 1, emit: (args) => `bf_abs ${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])}` }
 };
@@ -347,6 +355,7 @@ class CompileState {
   restPropsName = null;
   moduleStringConsts = new Map;
   localConstants = [];
+  staticLoopSourceBoundNames = new Set;
   localHelperNames = new Set;
   currentMemos = [];
   currentTypeDefinitions = [];
@@ -357,6 +366,7 @@ class CompileState {
   hoistedMemoLocals = new Map;
   loweringMatchers = [];
   nillablePropNames = new Set;
+  stringValueNames = new Set;
   rootScopeNodes = new Set;
   memoBackedLoopSlice = new Map;
   usesHtmlTemplate = false;
@@ -514,6 +524,178 @@ function collectNestedComponents(node, result) {
   }
 }
 
+// src/adapter/analysis/static-child-loop-bake.ts
+import { evaluateStaticLiteral, parseExpression, resolveStaticLoopSource } from "@barefootjs/jsx";
+function scalarToGoLiteral(value) {
+  if (typeof value === "string")
+    return `"${escapeGoString(value)}"`;
+  if (typeof value === "number")
+    return String(value);
+  if (typeof value === "boolean")
+    return value ? "true" : "false";
+  return null;
+}
+function analyzeBakeableStaticChildLoop(nested, localConstants, opts) {
+  if (!nested.loopParam || /^[{[]/.test(nested.loopParam))
+    return null;
+  const staticItemsResult = resolveStaticLoopSource(nested.loopArrayParsed, localConstants, opts);
+  if (staticItemsResult === null)
+    return null;
+  const items = [];
+  for (const item of staticItemsResult) {
+    const bindings = new Map([[nested.loopParam, item]]);
+    const inputFields = [];
+    for (const prop of nested.props) {
+      if (prop.isEventHandler)
+        continue;
+      if (prop.name.includes("-"))
+        continue;
+      const resolved = resolvePropValue(prop.value, bindings);
+      if (resolved === undefined)
+        return null;
+      const goValue = scalarToGoLiteral(resolved);
+      if (goValue === null)
+        return null;
+      inputFields.push({ goField: capitalizeFieldName(prop.name), goValue });
+    }
+    let dataKey = null;
+    if (nested.loopKey) {
+      const keyExpr = parseExpression(nested.loopKey);
+      const keyResolved = evaluateStaticLiteral(keyExpr, bindings);
+      if (keyResolved === null)
+        return null;
+      dataKey = String(keyResolved.value);
+    }
+    items.push({ inputFields, dataKey });
+  }
+  return { items };
+}
+function resolvePropValue(value, bindings) {
+  switch (value.kind) {
+    case "literal":
+      return value.value;
+    case "boolean-shorthand":
+    case "boolean-attr":
+      return true;
+    case "expression": {
+      if (!value.parsed)
+        return;
+      const resolved = evaluateStaticLiteral(value.parsed, bindings);
+      return resolved === null ? undefined : resolved.value;
+    }
+    default:
+      return;
+  }
+}
+
+// src/adapter/analysis/static-element-loop-bake.ts
+import {
+  evaluateStaticLiteral as evaluateStaticLiteral2,
+  resolveStaticLoopSource as resolveStaticLoopSource2
+} from "@barefootjs/jsx";
+var ALLOWED_ATTR_EXPRESSION_KINDS = new Set([
+  "identifier",
+  "member",
+  "index-access",
+  "literal"
+]);
+function analyzeBakeableStaticElementLoop(loop, localConstants, opts) {
+  if (loop.childComponent)
+    return null;
+  if (loop.method === "flatMap" || loop.flatMapCallback)
+    return null;
+  if (!loop.param || /^[{[]/.test(loop.param))
+    return null;
+  if (loop.index && loop.index !== "_")
+    return null;
+  if (loop.paramBindings && loop.paramBindings.length > 0)
+    return null;
+  if (loop.filterPredicate || loop.sortComparator)
+    return null;
+  if (loop.iterationShape || loop.objectIteration)
+    return null;
+  if (loop.bodyIsMultiRoot || loop.bodyIsItemConditional)
+    return null;
+  if (!isFoldableTree(loop.children))
+    return null;
+  const items = resolveStaticLoopSource2(loop.arrayParsed, localConstants, opts);
+  if (items === null)
+    return null;
+  for (const item of items) {
+    const bindings = new Map([[loop.param, item]]);
+    if (!allExpressionsFoldFor(loop.children, bindings))
+      return null;
+  }
+  return { items };
+}
+function isFoldableTree(nodes) {
+  for (const node of nodes) {
+    switch (node.type) {
+      case "text":
+      case "expression":
+        continue;
+      case "element":
+        if (!isFoldableAttrs(node))
+          return false;
+        if (!isFoldableTree(node.children))
+          return false;
+        continue;
+      default:
+        return false;
+    }
+  }
+  return true;
+}
+function isFoldableAttrs(element) {
+  for (const attr of element.attrs) {
+    if (attr.clientOnly)
+      continue;
+    switch (attr.value.kind) {
+      case "literal":
+      case "boolean-attr":
+      case "boolean-shorthand":
+        continue;
+      case "expression":
+        if (!attr.value.parsed || !ALLOWED_ATTR_EXPRESSION_KINDS.has(attr.value.parsed.kind))
+          return false;
+        continue;
+      default:
+        return false;
+    }
+  }
+  return true;
+}
+function allExpressionsFoldFor(nodes, bindings) {
+  for (const node of nodes) {
+    if (node.type === "expression") {
+      if (node.clientOnly)
+        continue;
+      if (!node.parsed || !resolvesToScalar(node.parsed, bindings))
+        return false;
+      continue;
+    }
+    if (node.type === "element") {
+      for (const attr of node.attrs) {
+        if (attr.clientOnly)
+          continue;
+        if (attr.value.kind !== "expression")
+          continue;
+        if (!attr.value.parsed || !resolvesToScalar(attr.value.parsed, bindings))
+          return false;
+      }
+      if (!allExpressionsFoldFor(node.children, bindings))
+        return false;
+    }
+  }
+  return true;
+}
+function resolvesToScalar(expr, bindings) {
+  const resolved = evaluateStaticLiteral2(expr, bindings);
+  if (resolved === null)
+    return false;
+  return scalarToGoLiteral(resolved.value) !== null;
+}
+
 // src/adapter/expr/helper-inline.ts
 function inlineLocalHelperCall(ctx, jsExpr, callParsed) {
   if (ctx.state.localHelperNames.size === 0)
@@ -701,7 +883,7 @@ function forEachValueChild(n, visit) {
 
 // src/adapter/expr/url-builder.ts
 import {
-  parseExpression,
+  parseExpression as parseExpression2,
   stringifyParsedExpr,
   isValidHelperId
 } from "@barefootjs/jsx";
@@ -734,7 +916,7 @@ function lowerRegisteredCall(ctx, jsExpr, preParsed) {
   if (!call) {
     if (!/^\s*[A-Za-z_$][\w$]*\s*\(/.test(jsExpr))
       return null;
-    const parsed = parseExpression(jsExpr);
+    const parsed = parseExpression2(jsExpr);
     if (parsed.kind !== "call")
       return null;
     call = parsed;
@@ -776,7 +958,7 @@ function typeInfoToGo(ctx, typeInfo, defaultValue) {
         case "string":
           return "string";
         case "number":
-          return "int";
+          return defaultValue !== undefined ? numberPrimitiveGoType(defaultValue) : "int";
         case "boolean":
           return "bool";
         default:
@@ -827,6 +1009,9 @@ function tsTypeStringToGo(ctx, tsType) {
     return t;
   return "interface{}";
 }
+function numberPrimitiveGoType(value) {
+  return /^-?\d+\.\d+$/.test(value) ? "float64" : "int";
+}
 function inferTypeFromValue(value) {
   if (value === "true" || value === "false")
     return "bool";
@@ -939,9 +1124,9 @@ function convertInitialValue(ctx, value, typeInfo, propsParams, preParsed) {
       return value === "true" ? "true" : "false";
     }
     if (typeInfo.primitive === "number") {
-      if (/^\d+$/.test(value))
+      if (/^-?\d+$/.test(value))
         return value;
-      if (/^\d+\.\d+$/.test(value))
+      if (/^-?\d+\.\d+$/.test(value))
         return value;
       return "0";
     }
@@ -966,6 +1151,12 @@ function convertInitialValue(ctx, value, typeInfo, propsParams, preParsed) {
       }
       return '""';
     }
+    if (ctx.state.localStructFields.has(typeInfo.raw)) {
+      const baked = jsLiteralToGo(ctx, typeInfo, preParsed);
+      if (baked !== null)
+        return baked;
+      return `${typeInfo.raw}{}`;
+    }
   }
   return "nil";
 }
@@ -1656,10 +1847,11 @@ function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallback
     const operand = String(body.right.value);
     const depName = getterCallName(body.left);
     if (depName) {
-      const signal = signals.find((s) => s.getter === depName);
-      if (signal) {
-        const signalInitial = getSignalInitialValueAsGo(ctx, signal.initialValue, propsParams, propFallbackVars);
-        return `${signalInitial} ${operator} ${operand}`;
+      const depInitial = resolveGetterValueAsGo(ctx, depName, signals, propsParams, propFallbackVars, resolving);
+      const isArithmeticSafe = depInitial !== null && !depInitial.startsWith("func(");
+      if (isArithmeticSafe) {
+        const wrapped = /\s/.test(depInitial) ? `(${depInitial})` : depInitial;
+        return `${wrapped} ${operator} ${operand}`;
       }
     }
     const propName = propsMemberName(body.left);
@@ -1694,9 +1886,9 @@ function memoInitialFromParsedBody(ctx, body, signals, propsParams, propFallback
   }
   const simpleDep = getterCallName(body);
   if (simpleDep) {
-    const signal = signals.find((s) => s.getter === simpleDep);
-    if (signal) {
-      return getSignalInitialValueAsGo(ctx, signal.initialValue, propsParams, propFallbackVars);
+    const depInitial = resolveGetterValueAsGo(ctx, simpleDep, signals, propsParams, propFallbackVars, resolving);
+    if (depInitial !== null) {
+      return depInitial;
     }
   }
   const simpleProp = propsMemberName(body);
@@ -1818,7 +2010,7 @@ function propsAccessNameFromParsed2(ctx, node) {
 
 // src/adapter/spread/spread-codegen.ts
 import ts2 from "typescript";
-import { parseExpression as parseExpression2, parseRecordIndexAccess } from "@barefootjs/jsx";
+import { parseExpression as parseExpression3, parseRecordIndexAccess } from "@barefootjs/jsx";
 function collectSpreadSlots(ctx, node) {
   const result = [];
   collectSpreadSlotsRecursive(ctx, node, result);
@@ -1925,7 +2117,7 @@ function parsedObjectLiteralToGoMap(parsed) {
 }
 function buildSpreadInitializer(ctx, spreadExpr, ir, parsed) {
   const trimmed = spreadExpr.trim();
-  const conditionalTree = parsed ?? parseExpression2(trimmed);
+  const conditionalTree = parsed ?? parseExpression3(trimmed);
   const conditional = buildConditionalSpreadInitializer(ctx, conditionalTree, ir);
   if (conditional !== undefined)
     return conditional;
@@ -1956,7 +2148,7 @@ function buildSpreadInitializer(ctx, spreadExpr, ir, parsed) {
     if (localConst?.value !== undefined) {
       const initTrimmed = localConst.value.trim();
       if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(initTrimmed)) {
-        const resolved = buildConditionalSpreadInitializer(ctx, parseExpression2(initTrimmed), ir);
+        const resolved = buildConditionalSpreadInitializer(ctx, parseExpression3(initTrimmed), ir);
         if (resolved)
           return resolved;
         if (resolved === null)
@@ -2087,8 +2279,47 @@ function buildPropTypeOverrides(ctx, ir) {
       }
     }
   }
+  for (const propName of collectToFixedPropNames(ir.root)) {
+    const param = ir.metadata.propsParams.find((p) => p.name === propName);
+    if (!param)
+      continue;
+    const resolved = overrides.get(propName) ?? typeInfoToGo(ctx, param.type, param.defaultValue);
+    if (resolved === "int") {
+      overrides.set(propName, "float64");
+    }
+  }
   return overrides;
 }
+function collectToFixedPropNames(root) {
+  const names = new Set;
+  const checkExpr = (expr) => {
+    if (expr?.kind === "array-method" && expr.method === "toFixed" && expr.object.kind === "identifier") {
+      names.add(expr.object.name);
+    }
+  };
+  const walk = (node) => {
+    if (!node)
+      return;
+    if (node.type === "expression")
+      checkExpr(node.parsed);
+    if (node.type === "conditional") {
+      checkExpr(node.parsedCondition);
+      walk(node.whenTrue);
+      walk(node.whenFalse);
+    }
+    if (node.type === "element") {
+      for (const attr of node.attrs) {
+        if (attr.value.kind === "expression")
+          checkExpr(attr.value.parsed);
+      }
+    }
+    if ("children" in node && Array.isArray(node.children)) {
+      node.children.forEach(walk);
+    }
+  };
+  walk(root);
+  return names;
+}
 function resolvePropGoType(ctx, param, propTypeOverrides) {
   const base = propTypeOverrides.get(param.name) ?? typeInfoToGo(ctx, param.type, param.defaultValue);
   if (param.optional && ctx.state.localStructFields.has(base)) {
@@ -2107,6 +2338,38 @@ function collectNillablePropNames(ctx, ir) {
   return nillable;
 }
 
+// src/adapter/props/prop-classes.ts
+import { collectLoopBoundNames } from "@barefootjs/jsx";
+function isStringTypeInfo(type) {
+  return type.kind === "primitive" && type.primitive === "string";
+}
+function isBareStringLiteral(initialValue) {
+  if (!initialValue)
+    return false;
+  const v = initialValue.trim();
+  return v.startsWith("'") && v.endsWith("'") || v.startsWith('"') && v.endsWith('"');
+}
+function collectStringValueNames(ir) {
+  const names = new Set;
+  for (const s of ir.metadata.signals) {
+    if (isStringTypeInfo(s.type) || isBareStringLiteral(s.initialValue)) {
+      names.add(s.getter);
+    }
+  }
+  for (const p of ir.metadata.propsParams) {
+    if (isStringTypeInfo(p.type))
+      names.add(p.name);
+  }
+  for (const c of ir.metadata.localConstants) {
+    if (c.type !== null && isStringTypeInfo(c.type) || isBareStringLiteral(c.value)) {
+      names.add(c.name);
+    }
+  }
+  for (const bound of collectLoopBoundNames(ir))
+    names.delete(bound);
+  return names;
+}
+
 // src/adapter/go-template-adapter.ts
 var STRING_METHODS = new Set([
   "replace",
@@ -2148,12 +2411,16 @@ class GoTemplateAdapter extends BaseAdapter {
     return this.state.errors;
   }
   inLoop = false;
+  bakedStaticChildLoopCache = new Map;
   loopParamStack = [];
+  loopKeyDepthStack = [];
   loopScalarItemStack = [];
   loopWrapperStack = [];
   loopVarRefCount = new Map;
   loopBindingStack = [];
   loopRestExcludeStack = [];
+  staticLoopItemStack = [];
+  staticLoopBakeFailed = false;
   childComponentShapes = new Map;
   childContextConsumers = new Map;
   constructor(options = {}) {
@@ -2169,6 +2436,8 @@ class GoTemplateAdapter extends BaseAdapter {
     this.state.restPropsName = ir.metadata.restPropsName ?? null;
     this.state.moduleStringConsts = this.collectModuleStringConsts(ir.metadata.localConstants);
     this.state.localConstants = ir.metadata.localConstants ?? [];
+    this.state.staticLoopSourceBoundNames = collectLoopBoundNames2(ir);
+    this.bakedStaticChildLoopCache = new Map;
     this.state.localHelperNames = new Set(this.state.localConstants.filter((c) => !c.isModule && c.containsArrow).map((c) => c.name));
     this.state.currentMemos = ir.metadata.memos ?? [];
     this.state.currentTypeDefinitions = ir.metadata.typeDefinitions ?? [];
@@ -2196,6 +2465,7 @@ class GoTemplateAdapter extends BaseAdapter {
     this.state.pendingChildrenDefines = [];
     this.primeCompileState(ir);
     this.state.nillablePropNames = collectNillablePropNames(this.emitCtx, ir);
+    this.state.stringValueNames = collectStringValueNames(ir);
     if (!options?.siblingTemplatesRegistered) {
       this.checkImportedLoopChildComponents(ir);
     }
@@ -2549,6 +2819,8 @@ ${goFields.join(`
       lines.push(`	${fieldName} ${goType}`);
     }
     for (const nested of inputNested) {
+      if (nested.loopMarkerId && this.getBakedStaticChildLoop(nested.loopMarkerId, nested, nested.loopArrayParsed, nested.loopParam, nested.loopKey))
+        continue;
       lines.push(`	${nested.name}s []${nested.name}Input`);
     }
     const takenInput = new Set(ir.metadata.propsParams.map((p) => capitalizeFieldName(p.name)));
@@ -2680,6 +2952,21 @@ ${goFields.join(`
     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`;
+      const baked = nested.loopMarkerId ? this.getBakedStaticChildLoop(nested.loopMarkerId, nested, nested.loopArrayParsed, nested.loopParam, nested.loopKey) : null;
+      if (baked) {
+        lines.push(`	${varName} := make([]${nested.name}Props, ${baked.items.length})`);
+        baked.items.forEach((item, i) => {
+          const fields = item.inputFields.map((f) => `${f.goField}: ${f.goValue}`).join(", ");
+          lines.push(`	${varName}[${i}] = New${nested.name}Props(${nested.name}Input{${fields}})`);
+          lines.push(`	${varName}[${i}].BfParent = scopeID`);
+          lines.push(`	${varName}[${i}].BfMount = "${nested.slotId}"`);
+          if (item.dataKey !== null) {
+            lines.push(`	${varName}[${i}].BfDataKey = ${JSON.stringify(item.dataKey)}`);
+          }
+        });
+        lines.push("");
+        continue;
+      }
       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)`);
@@ -2893,6 +3180,13 @@ ${goFields.join(`
                 break;
               }
             }
+            if (parsedValue) {
+              const goVal = parsedLiteralToGo(this.emitCtx, parsedValue);
+              if (goVal !== null) {
+                emitChildField(prop.name, goVal);
+                break;
+              }
+            }
             const resolvedValue = this.resolveDynamicPropValue(exprText, ir.metadata.signals, ir.metadata.memos, ir.metadata.propsParams);
             if (resolvedValue !== null) {
               emitChildField(prop.name, resolvedValue);
@@ -2900,6 +3194,24 @@ ${goFields.join(`
             break;
           }
           case "jsx-children":
+            if (prop.name !== "children") {
+              const text = this.extractTextChildren(prop.value.children);
+              if (text !== null) {
+                emitChildField(prop.name, JSON.stringify(text));
+              } else {
+                const html = this.extractHtmlChildren(prop.value.children);
+                if (html !== null) {
+                  this.state.usesHtmlTemplate = true;
+                  emitChildField(prop.name, `template.HTML(${JSON.stringify(html)})`);
+                } else {
+                  const scopedHtml = this.extractScopedHtmlChildren(prop.value.children);
+                  if (scopedHtml !== null) {
+                    this.state.usesHtmlTemplate = true;
+                    emitChildField(prop.name, `template.HTML(${scopedHtml})`);
+                  }
+                }
+              }
+            }
             break;
         }
       }
@@ -3541,6 +3853,17 @@ ${goFields.join(`
         return computeMemoInitialValueOrNull(this.emitCtx, memo, signals, propsParams, undefined, new Set([memo.name]));
       }
     }
+    const propsObjectName = this.state.propsObjectName;
+    const identifierPattern = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+    const bareIdentifier = identifierPattern.test(expr) ? expr : null;
+    const barePropAccess = propsObjectName && expr.startsWith(`${propsObjectName}.`) && identifierPattern.test(expr.slice(propsObjectName.length + 1)) ? expr.slice(propsObjectName.length + 1) : null;
+    const passthroughName = bareIdentifier ?? barePropAccess;
+    const localConst = this.state.localConstants.find((c) => c.name === passthroughName);
+    const isPropsDestructureAlias = localConst !== undefined && propsObjectName !== null && localConst.value === `${propsObjectName}.${passthroughName}`;
+    const shadowedByLocal = passthroughName !== null && (localConst !== undefined && !isPropsDestructureAlias || this.state.localHelperNames.has(passthroughName));
+    if (passthroughName && !shadowedByLocal && propsParams.some((p) => p.name === passthroughName)) {
+      return `in.${capitalizeFieldName(passthroughName)}`;
+    }
     return null;
   }
   inferMemoType(memo, signals, propsParamMap) {
@@ -3665,7 +3988,7 @@ ${goFields.join(`
     return this.renderElement(node);
   }
   emitText(node) {
-    return node.value;
+    return escapeHtml(node.value);
   }
   emitExpression(node) {
     return this.renderExpression(node);
@@ -3697,7 +4020,8 @@ ${goFields.join(`
   renderElement(element) {
     const tag = element.tag;
     const attrs = this.renderAttributes(element);
-    const children = this.renderChildren(element.children);
+    const dangerousHtml = this.renderDangerousInnerHtml(element);
+    const children = dangerousHtml !== null ? dangerousHtml : this.renderChildren(element.children);
     let hydrationAttrs = "";
     if (element.needsScope) {
       hydrationAttrs += ` ${this.renderScopeMarker(".ScopeID")}`;
@@ -3732,6 +4056,22 @@ ${goFields.join(`
     }
     return `<${tag}${attrs}${hydrationAttrs}>${children}</${tag}>`;
   }
+  renderDangerousInnerHtml(element) {
+    const resolution = resolveDangerousInnerHtml(element);
+    if (!resolution)
+      return null;
+    if (resolution.kind === "dynamic") {
+      this.errors.push(dangerousInnerHtmlDiagnostic(resolution.expr, resolution.loc));
+      return "";
+    }
+    const violation = dangerousInnerHtmlMetacharViolation(resolution.html, this.name);
+    if (violation) {
+      const attr = element.attrs.find(isDangerousInnerHtmlAttr);
+      this.errors.push(dangerousInnerHtmlDiagnostic(`{ __html: ${JSON.stringify(resolution.html)} }`, attr.loc, violation));
+      return "";
+    }
+    return resolution.html;
+  }
   renderExpression(expr) {
     if (expr.clientOnly) {
       if (expr.slotId) {
@@ -3925,7 +4265,7 @@ ${goFields.join(`
     const argsStr = args.map(emit).join(" ");
     return `${calleeStr} ${argsStr}`;
   }
-  member(object, property, _computed, emit) {
+  member(object, property, _computed, optional, emit) {
     const objHO = this.higherOrderShapeOf(object);
     if (property === "length" && objHO) {
       const result = this.renderFilterLengthExpr(objHO, emit);
@@ -3967,6 +4307,9 @@ ${goFields.join(`
     const obj = emit(object);
     if (property === "length")
       return `len ${obj}`;
+    if (optional) {
+      return `bf_get ${wrapIfMultiToken(obj)} ${JSON.stringify(goFieldNameForKey(property))}`;
+    }
     return `${obj}.${goFieldNameForKey(property)}`;
   }
   indexAccess(object, index, emit) {
@@ -3997,7 +4340,7 @@ ${goFields.join(`
       case "<=":
         return `le ${wl} ${wr}`;
       case "+":
-        return `bf_add ${wl} ${wr}`;
+        return this._emitPlus(left, right, wl, wr);
       case "-":
         return `bf_sub ${wl} ${wr}`;
       case "*":
@@ -4010,6 +4353,15 @@ ${goFields.join(`
         return `${l} ${op} ${r}`;
     }
   }
+  _emitPlus(leftExpr, rightExpr, leftRendered, rightRendered) {
+    if (isStringConcatBinary("+", leftExpr, rightExpr, (n) => this._isStringValueName(n))) {
+      return `bf_concat_str ${leftRendered} ${rightRendered}`;
+    }
+    return `bf_add ${leftRendered} ${rightRendered}`;
+  }
+  _isStringValueName(name) {
+    return this.state.stringValueNames.has(name);
+  }
   unary(op, argument, emit) {
     const arg = emit(argument);
     if (op === "!")
@@ -4221,6 +4573,12 @@ ${goFields.join(`
         const recv = emit(object);
         return `bf_trim ${wrapIfMultiToken(recv)}`;
       }
+      case "trimStart":
+      case "trimEnd": {
+        const fn = method === "trimStart" ? "bf_trim_start" : "bf_trim_end";
+        const recv = emit(object);
+        return `${fn} ${wrapIfMultiToken(recv)}`;
+      }
       case "toFixed": {
         const recv = emit(object);
         const digits = args.length >= 1 ? emit(args[0]) : "0";
@@ -4255,6 +4613,12 @@ ${goFields.join(`
         const newS = emit(args[1]);
         return `bf_replace ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(oldS)} ${wrapIfMultiToken(newS)}`;
       }
+      case "replaceAll": {
+        const recv = emit(object);
+        const oldS = emit(args[0]);
+        const newS = emit(args[1]);
+        return `bf_replace_all ${wrapIfMultiToken(recv)} ${wrapIfMultiToken(oldS)} ${wrapIfMultiToken(newS)}`;
+      }
       case "repeat": {
         const recv = emit(object);
         const count = args.length === 0 ? "0" : emit(args[0]);
@@ -4441,8 +4805,8 @@ ${goFields.join(`
     const value = negated ? "false" : "true";
     return `len (bf_filter ${arrayExpr} "${field}" ${value})`;
   }
-  renderPredicateCondition(pred, param) {
-    return this.renderFilterExpr(pred, param);
+  renderPredicateCondition(pred, param, datumField) {
+    return this.renderFilterExpr(pred, param, new Map, datumField ?? undefined);
   }
   needsParens(expr) {
     return expr.kind === "logical" || expr.kind === "unary" || expr.kind === "conditional";
@@ -4463,21 +4827,23 @@ ${goFields.join(`
     }
     return null;
   }
-  renderFilterExpr(expr, param, localVarMap = new Map) {
+  renderFilterExpr(expr, param, localVarMap = new Map, datumField) {
     if (this.filterExprDepth === 0)
       this.filterExprUnsupported = false;
     this.filterExprDepth++;
     try {
-      return this.renderFilterExprNode(expr, param, localVarMap);
+      return this.renderFilterExprNode(expr, param, localVarMap, datumField);
     } finally {
       this.filterExprDepth--;
     }
   }
-  renderFilterExprNode(expr, param, localVarMap) {
+  renderFilterExprNode(expr, param, localVarMap, datumField) {
+    const paramPrefix = datumField ? `.${datumField}` : "";
+    const paramDot = paramPrefix || ".";
     switch (expr.kind) {
       case "identifier": {
         if (expr.name === param) {
-          return ".";
+          return paramDot;
         }
         const signal = localVarMap.get(expr.name);
         if (signal) {
@@ -4495,24 +4861,24 @@ ${goFields.join(`
         return String(expr.value);
       case "member": {
         if (expr.object.kind === "identifier" && expr.object.name === param) {
-          return `.${capitalizeFieldName(expr.property)}`;
+          return `${paramPrefix}.${capitalizeFieldName(expr.property)}`;
         }
         if (expr.property === "length") {
           const innerHO = this.higherOrderShapeOf(expr.object);
           if (innerHO && innerHO.method === "filter") {
-            const lenExpr = this.renderFilterLengthExpr(innerHO, (e) => this.renderFilterExpr(e, param, localVarMap));
+            const lenExpr = this.renderFilterLengthExpr(innerHO, (e) => this.renderFilterExpr(e, param, localVarMap, datumField));
             if (lenExpr)
               return `(${lenExpr})`;
           }
         }
-        const obj = this.renderFilterExpr(expr.object, param, localVarMap);
+        const obj = this.renderFilterExpr(expr.object, param, localVarMap, datumField);
         if (this.filterExprUnsupported)
           return "false";
         return `${obj}.${capitalizeFieldName(expr.property)}`;
       }
       case "call": {
         if (expr.callee.kind === "member" && expr.callee.object.kind === "identifier" && expr.callee.object.name === param) {
-          return `.${capitalizeFieldName(expr.callee.property)}`;
+          return `${paramPrefix}.${capitalizeFieldName(expr.callee.property)}`;
         }
         if (expr.callee.kind === "identifier" && expr.args.length === 0) {
           return `$.${capitalizeFieldName(expr.callee.name)}`;
@@ -4520,13 +4886,13 @@ ${goFields.join(`
         if (asCallbackMethodCall3(expr) !== null) {
           return this.refuseFilterExprNode(expr);
         }
-        const result = this.renderFilterExpr(expr.callee, param, localVarMap);
+        const result = this.renderFilterExpr(expr.callee, param, localVarMap, datumField);
         if (this.filterExprUnsupported)
           return "false";
         return result;
       }
       case "unary": {
-        const arg = this.renderFilterExpr(expr.argument, param, localVarMap);
+        const arg = this.renderFilterExpr(expr.argument, param, localVarMap, datumField);
         if (this.filterExprUnsupported)
           return "false";
         if (expr.op === "!") {
@@ -4539,10 +4905,10 @@ ${goFields.join(`
         return arg;
       }
       case "binary": {
-        const left = this.renderFilterExpr(expr.left, param, localVarMap);
+        const left = this.renderFilterExpr(expr.left, param, localVarMap, datumField);
         if (this.filterExprUnsupported)
           return "false";
-        const right = this.renderFilterExpr(expr.right, param, localVarMap);
+        const right = this.renderFilterExpr(expr.right, param, localVarMap, datumField);
         if (this.filterExprUnsupported)
           return "false";
         switch (expr.op) {
@@ -4561,7 +4927,7 @@ ${goFields.join(`
           case "<=":
             return `le ${left} ${right}`;
           case "+":
-            return `bf_add ${left} ${right}`;
+            return this._emitPlus(expr.left, expr.right, left, right);
           case "-":
             return `bf_sub ${left} ${right}`;
           case "*":
@@ -4573,10 +4939,10 @@ ${goFields.join(`
         }
       }
       case "logical": {
-        const left = this.renderFilterExpr(expr.left, param, localVarMap);
+        const left = this.renderFilterExpr(expr.left, param, localVarMap, datumField);
         if (this.filterExprUnsupported)
           return "false";
-        const right = this.renderFilterExpr(expr.right, param, localVarMap);
+        const right = this.renderFilterExpr(expr.right, param, localVarMap, datumField);
         if (this.filterExprUnsupported)
           return "false";
         if (expr.op === "&&") {
@@ -4644,11 +5010,22 @@ ${goFields.join(`
     if (trimmed === "null" || trimmed === "undefined") {
       return '""';
     }
+    if (this.staticLoopItemStack.length > 0) {
+      const top = this.staticLoopItemStack[this.staticLoopItemStack.length - 1];
+      const parsedForBake = preParsed ?? parseExpression4(trimmed);
+      const resolved = evaluateStaticLiteral3(parsedForBake, new Map([[top.param, top.item]]));
+      const literal = resolved !== null ? scalarToGoLiteral(resolved.value) : null;
+      if (literal !== null) {
+        return literal;
+      }
+      this.staticLoopBakeFailed = true;
+      return '""';
+    }
     const staticIndexed = this.resolveStaticRecordLiteralIndex(trimmed);
     if (staticIndexed !== null) {
       return staticIndexed;
     }
-    if (/^[A-Za-z_$][\w$]*$/.test(trimmed)) {
+    if (!this.isLoopShadowedName(trimmed) && /^[A-Za-z_$][\w$]*$/.test(trimmed)) {
       const litConst = (this.state.localConstants ?? []).find((c) => c.name === trimmed);
       if (litConst?.value !== undefined) {
         const v = litConst.value.trim();
@@ -4666,7 +5043,7 @@ ${goFields.join(`
     if (inlined !== null) {
       return this.convertExpressionToGo(stringifyParsedExpr2(inlined), out, inlined);
     }
-    const parsed = preParsed ?? parseExpression3(trimmed);
+    const parsed = preParsed ?? parseExpression4(trimmed);
     const support = isSupported(parsed);
     if (!support.supported) {
       this.state.errors.push({
@@ -4684,10 +5061,15 @@ ${goFields.join(`
       out.parsed = parsed;
     return this.renderParsedExpr(parsed);
   }
+  isLoopShadowedName(name) {
+    return this.loopParamStack.length > 0 && this.loopParamStack[this.loopParamStack.length - 1] === name || this.loopVarRefCount.has(name) || this.isOuterLoopParam(name) || this.loopBindingStack.some((bindings) => bindings.has(name));
+  }
   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;
+    if (this.isLoopShadowedName(m[1]))
+      return null;
     const key = m[2] ?? m[3];
     const constInfo = (this.state.localConstants ?? []).find((c) => c.name === m[1] && c.isModule);
     if (constInfo?.value === undefined)
@@ -4793,7 +5175,7 @@ ${goFields.join(`
   }
   convertConditionToGo(jsCondition, preParsed) {
     const trimmed = jsCondition.trim();
-    const parsed = preParsed ?? parseExpression3(trimmed);
+    const parsed = preParsed ?? parseExpression4(trimmed);
     const support = isSupported(parsed);
     if (!support.supported) {
       this.state.errors.push({
@@ -4930,7 +5312,7 @@ ${goFields.join(`
             result = `le ${left} ${right}`;
             break;
           case "+":
-            result = `bf_add ${left} ${right}`;
+            result = this._emitPlus(expr.left, expr.right, left, right);
             break;
           case "-":
             result = `bf_sub ${left} ${right}`;
@@ -5014,6 +5396,29 @@ ${goFields.join(`
     }
     return;
   }
+  wrapperDatumField(loop) {
+    if (!loop.childComponent)
+      return null;
+    for (const prop of loop.childComponent.props) {
+      if (prop.isEventHandler)
+        continue;
+      if (prop.value.kind !== "expression")
+        continue;
+      const parsed = prop.value.parsed;
+      const isBareParamRef = parsed ? parsed.kind === "identifier" && parsed.name === loop.param : prop.value.expr.trim() === loop.param;
+      if (isBareParamRef)
+        return capitalizeFieldName(prop.name);
+    }
+    return null;
+  }
+  getBakedStaticChildLoop(markerId, childComponent, arrayParsed, param, key) {
+    if (this.bakedStaticChildLoopCache.has(markerId)) {
+      return this.bakedStaticChildLoopCache.get(markerId) ?? null;
+    }
+    const result = analyzeBakeableStaticChildLoop({ props: childComponent.props, loopArrayParsed: arrayParsed, loopParam: param, loopKey: key }, this.state.localConstants, { isNameShadowed: (name) => this.state.staticLoopSourceBoundNames.has(name) });
+    this.bakedStaticChildLoopCache.set(markerId, result);
+    return result;
+  }
   renderLoop(loop) {
     if (loop.clientOnly) {
       return `{{bfComment "loop:${loop.markerId}"}}{{bfComment "/loop:${loop.markerId}"}}`;
@@ -5034,8 +5439,13 @@ ${goFields.join(`
         }
       });
     }
+    const bakedChildLoop = loop.childComponent ? this.getBakedStaticChildLoop(loop.markerId, loop.childComponent, loop.arrayParsed, loop.param, loop.key ?? undefined) : null;
+    const bakedElementLoop = loop.childComponent ? null : analyzeBakeableStaticElementLoop(loop, this.state.localConstants, { isNameShadowed: (name) => this.state.staticLoopSourceBoundNames.has(name) });
+    if (bakedElementLoop) {
+      return this.renderUnrolledStaticElementLoop(loop, bakedElementLoop.items);
+    }
     const arrayName = loop.array.trim();
-    if (/^[A-Za-z_$][\w$]*$/.test(arrayName)) {
+    if (bakedChildLoop === null && /^[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({
@@ -5049,7 +5459,7 @@ ${goFields.join(`
         });
       }
     }
-    let goArray = this.convertExpressionToGo(loop.array);
+    let goArray = loop.childComponent ? "" : this.convertExpressionToGo(loop.array);
     const param = loop.param;
     let index = loop.index || "_";
     let rangeIndex = index;
@@ -5087,7 +5497,9 @@ ${goFields.join(`
     }
     this.loopScalarItemStack.push(this.scalarLiteralLoopGoType(loop.arrayParsed, loop.itemType) !== null);
     this.loopWrapperStack.push(!!loop.childComponent);
+    this.loopKeyDepthStack.push(loop.depth);
     const children = this.renderChildren(loop.children);
+    this.loopKeyDepthStack.pop();
     this.loopWrapperStack.pop();
     this.loopScalarItemStack.pop();
     const itemMarker = this.loopItemMarker(loop);
@@ -5115,7 +5527,8 @@ ${goFields.join(`
     if (loop.filterPredicate) {
       let filterCond;
       if (loop.filterPredicate.predicate) {
-        filterCond = this.renderPredicateCondition(loop.filterPredicate.predicate, loop.filterPredicate.param);
+        const datumField = this.wrapperDatumField(loop);
+        filterCond = this.renderPredicateCondition(loop.filterPredicate.predicate, loop.filterPredicate.param, datumField);
       } else {
         filterCond = "true";
       }
@@ -5123,6 +5536,38 @@ ${goFields.join(`
     }
     return `{{bfComment "loop:${loop.markerId}"}}{{range $${rangeIndex}, $${rangeValue} := ${goArray}}}${itemMarker}${children}{{end}}{{bfComment "/loop:${loop.markerId}"}}`;
   }
+  renderUnrolledStaticElementLoop(loop, items) {
+    this.inLoop = true;
+    this.loopWrapperStack.push(false);
+    this.loopKeyDepthStack.push(loop.depth);
+    this.loopScalarItemStack.push(this.scalarLiteralLoopGoType(loop.arrayParsed, loop.itemType) !== null);
+    this.loopParamStack.push(loop.param);
+    let body = "";
+    for (const item of items) {
+      this.staticLoopItemStack.push({ param: loop.param, item });
+      body += this.renderChildren(loop.children);
+      this.staticLoopItemStack.pop();
+      if (this.staticLoopBakeFailed) {
+        this.staticLoopBakeFailed = false;
+        this.state.errors.push({
+          code: "BF101",
+          severity: "error",
+          message: `Loop array \`${loop.array.trim()}\` could not be fully unrolled — an expression in the loop body did not resolve against every item as the compile-time analysis expected.`,
+          loc: loop.loc ?? this.makeLoc(),
+          suggestion: {
+            message: "This indicates a bug in the Go adapter's static-loop unrolling (#2224) rather than an unsupported source pattern; please file a bug with a reproduction."
+          }
+        });
+        break;
+      }
+    }
+    this.loopParamStack.pop();
+    this.loopScalarItemStack.pop();
+    this.loopKeyDepthStack.pop();
+    this.loopWrapperStack.pop();
+    this.inLoop = false;
+    return `{{bfComment "loop:${loop.markerId}"}}${body}{{bfComment "/loop:${loop.markerId}"}}`;
+  }
   loopItemMarker(loop) {
     if (loop.bodyIsMultiRoot)
       return `{{bfComment "bf-loop-i"}}`;
@@ -5230,7 +5675,7 @@ ${goFields.join(`
 ${children}`;
   }
   elementAttrEmitter = {
-    emitLiteral: (value, name) => `${name}="${value.value}"`,
+    emitLiteral: (value, name) => `${name}="${escapeHtml(value.value)}"`,
     emitExpression: (value, name) => {
       if (name === "style") {
         const css = this.tryLowerStyleObject(value.expr);
@@ -5242,7 +5687,7 @@ ${children}`;
         const body = name.startsWith("aria-") ? `${name}="true"` : name;
         return `${preamble}{{if ${goCond}}}${body}{{end}}`;
       }
-      const parsed = value.parsed ?? parseExpression3(value.expr.trim());
+      const parsed = value.parsed ?? parseExpression4(value.expr.trim());
       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;
@@ -5307,7 +5752,7 @@ ${children}`;
     if (!entries)
       return null;
     for (const e of entries) {
-      if (e.kind === "expr" && !isSupported(parseExpression3(e.expr)).supported)
+      if (e.kind === "expr" && !isSupported(parseExpression4(e.expr)).supported)
         return null;
     }
     return entries.map((e) => e.kind === "literal" ? `${this.escapeAttrText(e.cssKey)}:${this.escapeAttrText(e.value)}` : `${this.escapeAttrText(e.cssKey)}:{{${this.convertExpressionToGo(e.expr)}}}`).join(";");
@@ -5317,12 +5762,15 @@ ${children}`;
     for (const attr of element.attrs) {
       if (attr.clientOnly)
         continue;
+      if (isDangerousInnerHtmlAttr(attr))
+        continue;
       let attrName;
       if (attr.name === "className")
         attrName = "class";
-      else if (attr.name === "key")
-        attrName = "data-key";
-      else
+      else if (attr.name === "key") {
+        const depth = this.loopKeyDepthStack.at(-1) ?? 0;
+        attrName = depth > 0 ? `data-key-${depth}` : "data-key";
+      } else
         attrName = attr.name;
       const lowered = emitAttrValue(attr.value, this.elementAttrEmitter, attrName);
       if (lowered)
@@ -5422,42 +5870,18 @@ ${children}`;
 var goTemplateAdapter = new GoTemplateAdapter;
 // src/conformance-pins.ts
 var conformancePins = {
-  "static-array-children": [{ code: "BF103", severity: "error" }],
-  "todo-app": [{ code: "BF103", severity: "error" }],
-  "todo-app-ssr": [{ code: "BF103", severity: "error" }],
   "static-array-from-props": [{ code: "BF101", severity: "error" }],
-  "static-array-from-props-with-component": [
-    { code: "BF103", severity: "error" },
-    { code: "BF101", severity: "error" }
-  ],
+  "static-array-from-props-with-component": [{ code: "BF101", severity: "error" }],
   "filter-nested-callback-predicate": [
     { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2038" }
   ],
   "filter-nested-find-predicate": [
     { code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2038" }
   ],
-  "array-map-function-reference": [{ code: "BF101", severity: "error" }],
-  "dangerous-inner-html": [{ code: "BF101", severity: "error" }],
-  "string-replaceall": [{ code: "BF101", severity: "error" }]
+  "dangerous-inner-html-dynamic": [{ code: "BF101", severity: "error", issue: "https://github.com/piconic-ai/barefootjs/issues/2215" }]
 };
 // src/render-divergences.ts
-var renderDivergences = {
-  "html-entity-text": "`&copy;` in JSX literal text: Hono decodes to `©`, this adapter re-emits the raw entity — same DOM, different bytes",
-  "string-concat-plus": "`'Hello, ' + name` renders \"0\" — JS string-concat `+` lowered through numeric addition",
-  "optional-chaining-prop": "`user?.name ?? …` on an object prop: generated Go fails to run (exit 1) — optional chaining into a struct/map prop has no lowering",
-  "number-tofixed": "`.toFixed(2)` on a number PROP: generated Go fails to run (exit 1)",
-  "math-methods": "Math.min/max/abs over a signal: generated Go fails to run (exit 1) — only Math.floor is registered",
-  "static-attr-escape": 'static attribute values are not HTML-escaped (`title="Fish & Chips"` emitted raw; Hono escapes)',
-  "object-entries-map": "`Object.entries(prop).map(([k, v]) => …)`: generated Go fails to run (exit 1) — no object-iteration loop lowering",
-  "nested-loop-outer-binding": "nested-loop inner items carry `data-key` where the reference emits the depth-suffixed `data-key-1`",
-  "jsx-element-prop": "a JSX element passed as a NON-children prop renders an empty slot — the element value is silently dropped",
-  "grandchild-composition": "three-level composition: the grandchild's threaded prop renders EMPTY — prop forwarding through two template-render layers loses the value",
-  "child-primitive-props": "numeric/boolean LITERAL props on a child (`count={5}` `active={true}`) render as Go zero values (0 / false)",
-  "memo-chain": "a memo derived from another memo renders EMPTY for the second layer — the constructor folds only one derivation level",
-  "signal-object-field": "object-valued signal (`user().name`): generated Go fails to run (exit 1) — no struct synthesis outside loops",
-  "string-slice": '`.slice()` on a STRING routes through the array `bf_slice` helper and renders "[]" instead of the substring',
-  "string-trim-sided": "`.trimStart()` / `.trimEnd()`: generated Go fails to run (exit 1) — only both-sides `bf_trim` exists"
-};
+var renderDivergences = {};
 export {
   renderDivergences,
   goTemplateAdapter,