@barefootjs/go-template 0.18.5 → 0.19.0

package/dist/build.js

@@ -364,8 +364,8 @@ var init_path = __esm(() => {
 // src/adapter/go-template-adapter.ts
 import {
   BaseAdapter,
-  isBooleanAttr,
-  parseExpression as parseExpression3,
+  isBooleanAttr as isBooleanAttr2,
+  parseExpression as parseExpression4,
   stringifyParsedExpr as stringifyParsedExpr2,
   parseStyleObjectEntries,
   isSupported,
@@ -383,7 +383,13 @@ import {
   prepareLoweringMatchers,
   envSignalReaderFor,
   computeSsrSeedPlan,
-  isStringConcatBinary
+  isStringConcatBinary,
+  isDangerousInnerHtmlAttr,
+  resolveDangerousInnerHtml,
+  dangerousInnerHtmlMetacharViolation,
+  dangerousInnerHtmlDiagnostic,
+  collectLoopBoundNames as collectLoopBoundNames2,
+  evaluateStaticLiteral as evaluateStaticLiteral3
 } from "@barefootjs/jsx";
 import { findInterpolationEnd } from "@barefootjs/jsx/scanner";
 import { BF_REGION, escapeHtml } from "@barefootjs/shared";
@@ -689,6 +695,7 @@ class CompileState {
   restPropsName = null;
   moduleStringConsts = new Map;
   localConstants = [];
+  staticLoopSourceBoundNames = new Set;
   localHelperNames = new Set;
   currentMemos = [];
   currentTypeDefinitions = [];
@@ -699,6 +706,8 @@ class CompileState {
   hoistedMemoLocals = new Map;
   loweringMatchers = [];
   nillablePropNames = new Set;
+  nullishConsumedPropNames = new Set;
+  omittableAttrConsumedPropNames = new Set;
   stringValueNames = new Set;
   rootScopeNodes = new Set;
   memoBackedLoopSlice = new Map;
@@ -857,6 +866,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)
@@ -1044,7 +1225,7 @@ function forEachValueChild(n, visit) {
 
 // src/adapter/expr/url-builder.ts
 import {
-  parseExpression,
+  parseExpression as parseExpression2,
   stringifyParsedExpr,
   isValidHelperId
 } from "@barefootjs/jsx";
@@ -1077,7 +1258,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;
@@ -1276,7 +1457,7 @@ function convertInitialValue(ctx, value, typeInfo, propsParams, preParsed) {
       return `in.${capitalizeFieldName(value)}`;
     }
   }
-  const propName = ctx.extractPropNameFromInitialValue(value);
+  const propName = ctx.extractPropNameFromInitialValue(value, preParsed);
   if (propName && propsParams?.some((p) => p.name === propName)) {
     return `in.${capitalizeFieldName(propName)}`;
   }
@@ -2171,7 +2352,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);
@@ -2278,7 +2459,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;
@@ -2309,7 +2490,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)
@@ -2420,11 +2601,12 @@ function recordIndexAccessToGoMap(ctx, val, ir) {
 }
 
 // src/adapter/props/prop-types.ts
+import { isBooleanAttr } from "@barefootjs/jsx";
 function buildPropTypeOverrides(ctx, ir) {
   const overrides = new Map;
   for (const signal of ir.metadata.signals) {
     const propNames = [signal.initialValue];
-    const extracted = ctx.extractPropNameFromInitialValue(signal.initialValue);
+    const extracted = ctx.extractPropNameFromInitialValue(signal.initialValue, signal.parsed);
     if (extracted)
       propNames.push(extracted);
     for (const propName of propNames) {
@@ -2481,11 +2663,96 @@ function collectToFixedPropNames(root) {
   walk(root);
   return names;
 }
+var NULLISH_SCALAR_GO_TYPES = new Set(["string", "int", "float64", "bool"]);
+function collectNullishConsumedPropNames(ctx, ir) {
+  const names = new Set;
+  const optionalParams = new Set(ir.metadata.propsParams.filter((p) => p.optional && p.defaultValue == null).map((p) => p.name));
+  if (optionalParams.size === 0)
+    return names;
+  const propsObject = ctx.state.propsObjectName;
+  const propNameOfLeft = (left) => {
+    if (left.kind === "identifier")
+      return left.name;
+    if (left.kind === "member" && !left.computed && left.object.kind === "identifier" && left.object.name === propsObject) {
+      return left.property;
+    }
+    return null;
+  };
+  const isZeroEquivalentLiteral = (right) => right.kind === "literal" && (right.value === "" || right.value === false || right.value === null || right.literalType === "number" && Number(right.value) === 0);
+  const walk = (node) => {
+    if (!node || typeof node !== "object")
+      return;
+    if (Array.isArray(node)) {
+      for (const item of node)
+        walk(item);
+      return;
+    }
+    const rec = node;
+    if (rec.kind === "logical" && rec.op === "??" && rec.left && rec.right) {
+      const propName = propNameOfLeft(rec.left);
+      if (propName && optionalParams.has(propName) && !isZeroEquivalentLiteral(rec.right)) {
+        names.add(propName);
+      }
+    }
+    for (const value of Object.values(rec))
+      walk(value);
+  };
+  walk(ir.root);
+  for (const signal of ir.metadata.signals) {
+    const match = ctx.extractPropFallback(signal.initialValue, signal.parsed);
+    if (!match || !optionalParams.has(match.propName))
+      continue;
+    const f = match.goFallback;
+    if (f === '""' || f === "false" || f === "nil" || Number(f) === 0)
+      continue;
+    names.add(match.propName);
+  }
+  return names;
+}
+function collectOmittableAttrConsumedPropNames(ctx, ir) {
+  const names = new Set;
+  const optionalParams = new Set(ir.metadata.propsParams.filter((p) => p.optional && p.defaultValue == null).map((p) => p.name));
+  if (optionalParams.size === 0)
+    return names;
+  const propsObject = ctx.state.propsObjectName;
+  const walk = (node) => {
+    if (!node || typeof node !== "object")
+      return;
+    if (Array.isArray(node)) {
+      for (const item of node)
+        walk(item);
+      return;
+    }
+    const rec = node;
+    if (rec.type === "element" && Array.isArray(rec.attrs)) {
+      for (const attr of rec.attrs) {
+        if (attr.name === "class" || attr.name === "className" || attr.name === "style")
+          continue;
+        if (isBooleanAttr(attr.name))
+          continue;
+        if (attr.value?.kind !== "expression" || attr.value.presenceOrUndefined)
+          continue;
+        const bareId = String(attr.value.expr ?? "").trim();
+        const propName = propsObject && bareId.startsWith(`${propsObject}.`) ? bareId.slice(propsObject.length + 1) : bareId;
+        if (/^[A-Za-z_$][\w$]*$/.test(propName) && optionalParams.has(propName)) {
+          names.add(propName);
+        }
+      }
+    }
+    for (const value of Object.values(rec))
+      walk(value);
+  };
+  walk(ir.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)) {
     return "map[string]interface{}";
   }
+  if (param.optional && param.type.kind === "primitive" && (ctx.state.nullishConsumedPropNames.has(param.name) || ctx.state.omittableAttrConsumedPropNames.has(param.name)) && NULLISH_SCALAR_GO_TYPES.has(base)) {
+    return "interface{}";
+  }
   return base;
 }
 function collectNillablePropNames(ctx, ir) {
@@ -2500,6 +2767,7 @@ function collectNillablePropNames(ctx, ir) {
 }
 
 // src/adapter/props/prop-classes.ts
+import { collectLoopBoundNames } from "@barefootjs/jsx";
 function isStringTypeInfo(type) {
   return type.kind === "primitive" && type.primitive === "string";
 }
@@ -2520,6 +2788,13 @@ function collectStringValueNames(ir) {
     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;
 }
 
@@ -2556,14 +2831,15 @@ class GoTemplateAdapter extends BaseAdapter {
     state: this.state,
     convertExpressionToGo: (jsExpr, out, preParsed) => this.convertExpressionToGo(jsExpr, out, preParsed),
     convertConditionToGo: (jsCondition, preParsed) => this.convertConditionToGo(jsCondition, preParsed),
-    extractPropNameFromInitialValue: (initialValue) => this.extractPropNameFromInitialValue(initialValue),
-    extractPropFallback: (initialValue) => this.extractPropFallback(initialValue),
+    extractPropNameFromInitialValue: (initialValue, preParsed) => this.extractPropNameFromInitialValue(initialValue, preParsed),
+    extractPropFallback: (initialValue, preParsed) => this.extractPropFallback(initialValue, preParsed),
     resolveModuleStringConst: (name) => this.resolveModuleStringConst(name)
   };
   get errors() {
     return this.state.errors;
   }
   inLoop = false;
+  bakedStaticChildLoopCache = new Map;
   loopParamStack = [];
   loopKeyDepthStack = [];
   loopScalarItemStack = [];
@@ -2571,6 +2847,8 @@ class GoTemplateAdapter extends BaseAdapter {
   loopVarRefCount = new Map;
   loopBindingStack = [];
   loopRestExcludeStack = [];
+  staticLoopItemStack = [];
+  staticLoopBakeFailed = false;
   childComponentShapes = new Map;
   childContextConsumers = new Map;
   constructor(options = {}) {
@@ -2586,6 +2864,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 ?? [];
@@ -2604,6 +2884,10 @@ class GoTemplateAdapter extends BaseAdapter {
     }
     this.state.loweringMatchers = prepareLoweringMatchers(ir.metadata);
     augmentInheritedPropAccesses(ir);
+    this.buildLocalTypeTables(ir, ir.metadata.componentName);
+    this.state.nullishConsumedPropNames = collectNullishConsumedPropNames(this.emitCtx, ir);
+    this.state.omittableAttrConsumedPropNames = collectOmittableAttrConsumedPropNames(this.emitCtx, ir);
+    this.state.nillablePropNames = collectNillablePropNames(this.emitCtx, ir);
   }
   generate(ir, options) {
     this.state.componentName = ir.metadata.componentName;
@@ -2612,7 +2896,6 @@ class GoTemplateAdapter extends BaseAdapter {
     this.state.templateVarCounter = 0;
     this.state.pendingChildrenDefines = [];
     this.primeCompileState(ir);
-    this.state.nillablePropNames = collectNillablePropNames(this.emitCtx, ir);
     this.state.stringValueNames = collectStringValueNames(ir);
     if (!options?.siblingTemplatesRegistered) {
       this.checkImportedLoopChildComponents(ir);
@@ -2967,6 +3250,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)));
@@ -3098,6 +3383,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)`);
@@ -3114,10 +3414,18 @@ ${goFields.join(`
     this.emitStaticBodyWrappers(lines, ir, componentName, staticWithBody, emittedWrapperVars);
     const propFallbackVars = this.collectPropFallbackVars(ir);
     for (const [, info] of propFallbackVars) {
-      lines.push(`	${info.varName} := in.${info.fieldName}`);
-      lines.push(`	if ${info.varName} == ${info.zeroLiteral} {`);
-      lines.push(`		${info.varName} = ${info.goFallback}`);
-      lines.push(`	}`);
+      if (info.assertType) {
+        const deref = info.assertType === "int" ? `bf.ToInt(in.${info.fieldName})` : info.assertType === "float64" ? `bf.ToFloat64(in.${info.fieldName})` : `in.${info.fieldName}.(${info.assertType})`;
+        lines.push(`	var ${info.varName} ${info.assertType} = ${info.goFallback}`);
+        lines.push(`	if in.${info.fieldName} != nil {`);
+        lines.push(`		${info.varName} = ${deref}`);
+        lines.push(`	}`);
+      } else {
+        lines.push(`	${info.varName} := in.${info.fieldName}`);
+        lines.push(`	if ${info.varName} == ${info.zeroLiteral} {`);
+        lines.push(`		${info.varName} = ${info.goFallback}`);
+        lines.push(`	}`);
+      }
     }
     if (propFallbackVars.size > 0)
       lines.push("");
@@ -3197,7 +3505,7 @@ ${goFields.join(`
       const fieldName = capitalizeFieldName(signal.getter);
       if (propFieldNames.has(fieldName))
         continue;
-      const fallbackMatch = this.extractPropFallback(signal.initialValue);
+      const fallbackMatch = this.extractPropFallback(signal.initialValue, signal.parsed);
       const hoisted = fallbackMatch ? propFallbackVars.get(fallbackMatch.propName) : undefined;
       if (hoisted) {
         lines.push(`		${fieldName}: ${hoisted.varName},`);
@@ -4043,8 +4351,9 @@ ${goFields.join(`
     for (const nested of findNestedComponents(ir.root)) {
       localTaken.add(`${nested.name.charAt(0).toLowerCase()}${nested.name.slice(1)}s`);
     }
+    const propTypeOverrides = buildPropTypeOverrides(this.emitCtx, ir);
     for (const signal of ir.metadata.signals) {
-      const match = this.extractPropFallback(signal.initialValue);
+      const match = this.extractPropFallback(signal.initialValue, signal.parsed);
       if (!match)
         continue;
       if (result.has(match.propName))
@@ -4055,6 +4364,8 @@ ${goFields.join(`
       if (goPropDefault(param.defaultValue) !== null)
         continue;
       const fieldName = capitalizeFieldName(match.propName);
+      const concreteType = propTypeOverrides.get(param.name) ?? typeInfoToGo(this.emitCtx, param.type, param.defaultValue);
+      const nullishLowered = NULLISH_SCALAR_GO_TYPES.has(concreteType) && resolvePropGoType(this.emitCtx, param, propTypeOverrides) === "interface{}";
       let zeroLiteral;
       if (match.goFallback === "true" || match.goFallback === "false") {
         zeroLiteral = "false";
@@ -4065,20 +4376,31 @@ ${goFields.join(`
       } else {
         continue;
       }
-      if (match.goFallback === zeroLiteral)
-        continue;
-      if (zeroLiteral === "0" && Number(match.goFallback) === 0)
-        continue;
+      if (!nullishLowered) {
+        if (match.goFallback === zeroLiteral)
+          continue;
+        if (zeroLiteral === "0" && Number(match.goFallback) === 0)
+          continue;
+      }
       let varName = match.propName;
       while (localTaken.has(varName) || GO_KEYWORDS.has(varName)) {
         varName += "_";
       }
       localTaken.add(varName);
-      result.set(match.propName, { varName, fieldName, goFallback: match.goFallback, zeroLiteral });
+      result.set(match.propName, {
+        varName,
+        fieldName,
+        goFallback: match.goFallback,
+        zeroLiteral,
+        ...nullishLowered ? { assertType: concreteType } : {}
+      });
     }
     return result;
   }
-  extractPropFallback(initialValue) {
+  extractPropFallback(initialValue, preParsed) {
+    const structural = preParsed ? this.extractPropFallbackFromParsed(preParsed) : null;
+    if (structural)
+      return structural;
     if (!this.state.propsObjectName)
       return null;
     const trimmed = initialValue.trim();
@@ -4092,9 +4414,38 @@ ${goFields.join(`
       return null;
     return { propName: m[1], goFallback };
   }
-  extractPropNameFromInitialValue(initialValue) {
-    if (!this.state.propsObjectName)
+  extractPropFallbackFromParsed(preParsed) {
+    if (preParsed.kind !== "logical" || preParsed.op !== "??")
+      return null;
+    const left = preParsed.left;
+    const propName = left.kind === "identifier" && !this.state.propsObjectName ? left.name : left.kind === "member" && !left.computed && left.object.kind === "identifier" && left.object.name === this.state.propsObjectName ? left.property : null;
+    if (!propName)
+      return null;
+    let right = preParsed.right;
+    let negate = "";
+    if (right.kind === "unary" && right.op === "-") {
+      negate = "-";
+      right = right.argument;
+    }
+    if (right.kind !== "literal")
+      return null;
+    if (negate && right.literalType !== "number")
+      return null;
+    if (right.literalType === "string") {
+      return { propName, goFallback: JSON.stringify(right.value) };
+    }
+    const goFallback = goPropDefault(negate + (right.raw ?? String(right.value)));
+    if (goFallback === null)
+      return null;
+    return { propName, goFallback };
+  }
+  extractPropNameFromInitialValue(initialValue, preParsed) {
+    if (!this.state.propsObjectName) {
+      if (preParsed?.kind === "logical" && (preParsed.op === "??" || preParsed.op === "||") && preParsed.left.kind === "identifier") {
+        return preParsed.left.name;
+      }
       return null;
+    }
     const trimmed = initialValue.trim();
     const name = this.state.propsObjectName;
     const direct = new RegExp(`^${name}\\.(\\w+)(?:\\s*(?:\\?\\?|\\|\\|)\\s*.+)?$`);
@@ -4151,7 +4502,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")}`;
@@ -4186,6 +4538,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) {
@@ -4489,8 +4857,20 @@ ${goFields.join(`
     const wrapRight = wrapIfMultiToken(emit(right));
     if (op === "&&")
       return `and ${wrapLeft} ${wrapRight}`;
+    if (op === "??" && this.nillablePropNameOf(left) !== null) {
+      return `bf_nullish ${wrapLeft} ${wrapRight}`;
+    }
     return `or ${wrapLeft} ${wrapRight}`;
   }
+  nillablePropNameOf(expr) {
+    let name = null;
+    if (expr.kind === "identifier") {
+      name = expr.name;
+    } else if (expr.kind === "member" && !expr.computed && expr.object.kind === "identifier" && expr.object.name === this.state.propsObjectName) {
+      name = expr.property;
+    }
+    return name !== null && this.state.nullishConsumedPropNames.has(name) && this.state.nillablePropNames.has(name) ? name : null;
+  }
   conditional(test, consequent, alternate, emit) {
     const t = emit(test);
     const c = this.renderConditionalBranch(consequent);
@@ -4919,8 +5299,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";
@@ -4941,21 +5321,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) {
@@ -4973,24 +5355,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)}`;
@@ -4998,13 +5380,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 === "!") {
@@ -5017,10 +5399,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) {
@@ -5051,10 +5433,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 === "&&") {
@@ -5122,11 +5504,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();
@@ -5144,7 +5537,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({
@@ -5162,10 +5555,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)
@@ -5271,7 +5669,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({
@@ -5492,6 +5890,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}"}}`;
@@ -5512,8 +5933,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({
@@ -5527,7 +5953,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;
@@ -5595,7 +6021,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";
       }
@@ -5603,6 +6030,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"}}`;
@@ -5717,12 +6176,12 @@ ${children}`;
         if (css !== null)
           return `style="${css}"`;
       }
-      if (isBooleanAttr(name) || value.presenceOrUndefined) {
+      if (isBooleanAttr2(name) || value.presenceOrUndefined) {
         const { condition: goCond, preamble } = this.convertConditionToGo(value.expr, value.parsed);
         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;
@@ -5787,7 +6246,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(";");
@@ -5797,6 +6256,8 @@ ${children}`;
     for (const attr of element.attrs) {
       if (attr.clientOnly)
         continue;
+      if (isDangerousInnerHtmlAttr(attr))
+        continue;
       let attrName;
       if (attr.name === "className")
         attrName = "class";