@barefootjs/jsx 0.25.0 → 0.26.0

package/dist/index.js

@@ -6956,6 +6956,37 @@ function extractFreeIdentifiersFromNode(node) {
   visit2(node);
   return ids;
 }
+function extractFreeTypeIdentifiersFromNode(node) {
+  const ids = new Set;
+  const boundTypeParams = new Set;
+  function rootName(name) {
+    return ts8.isQualifiedName(name) ? rootName(name.left) : name;
+  }
+  function visit2(n) {
+    if (ts8.isTypeReferenceNode(n)) {
+      const name = rootName(n.typeName).text;
+      if (!boundTypeParams.has(name))
+        ids.add(name);
+    }
+    if (ts8.isTypeQueryNode(n)) {
+      const name = rootName(n.exprName).text;
+      if (!boundTypeParams.has(name))
+        ids.add(name);
+    }
+    if (ts8.isFunctionLike(n) && n.typeParameters && n.typeParameters.length > 0) {
+      const names = n.typeParameters.map((p) => p.name.text);
+      for (const p of names)
+        boundTypeParams.add(p);
+      ts8.forEachChild(n, visit2);
+      for (const p of names)
+        boundTypeParams.delete(p);
+      return;
+    }
+    ts8.forEachChild(n, visit2);
+  }
+  visit2(node);
+  return ids;
+}
 function initializerShapeContainsJsx(node) {
   let found = false;
   function visit2(n) {
@@ -7800,16 +7831,17 @@ function buildEntryImportIndex(sf, filePath) {
       continue;
     if (!ts8.isStringLiteral(stmt.moduleSpecifier))
       continue;
-    if (stmt.importClause?.isTypeOnly)
-      continue;
     const src = stmt.moduleSpecifier.text;
     const targetKey = src.startsWith("./") || src.startsWith("../") ? resolveRelativeImportToFile(src, filePath) ?? "unresolved:" + src : src;
+    const wholeTypeOnly = stmt.importClause?.isTypeOnly === true;
     const namedBindings = stmt.importClause?.namedBindings;
     if (namedBindings && ts8.isNamedImports(namedBindings)) {
       for (const el of namedBindings.elements) {
-        if (el.isTypeOnly)
-          continue;
-        index.set(el.name.text, { targetKey, exportedName: (el.propertyName ?? el.name).text });
+        index.set(el.name.text, {
+          targetKey,
+          exportedName: (el.propertyName ?? el.name).text,
+          isTypeOnly: wholeTypeOnly || el.isTypeOnly
+        });
       }
     }
   }
@@ -7839,6 +7871,9 @@ function collectEntryBindingNames(sf) {
     if ((ts8.isFunctionDeclaration(node) || ts8.isClassDeclaration(node) || ts8.isEnumDeclaration(node)) && node.name) {
       names.add(node.name.text);
     }
+    if ((ts8.isTypeAliasDeclaration(node) || ts8.isInterfaceDeclaration(node)) && node.name) {
+      names.add(node.name.text);
+    }
     if (ts8.isFunctionLike(node)) {
       for (const p of node.parameters) {
         const out = [];
@@ -8034,7 +8069,11 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
           const required = [];
           const pending = [];
           let declinedEntry = null;
-          for (const ref of capture.importedRefs) {
+          const allRefs = [
+            ...capture.importedRefs.map((r) => ({ ...r, isTypeOnly: false })),
+            ...capture.importedTypeRefs.map((r) => ({ ...r, isTypeOnly: true }))
+          ];
+          for (const ref of allRefs) {
             let specifier;
             let targetKey;
             if (ref.source.startsWith("./") || ref.source.startsWith("../")) {
@@ -8054,7 +8093,7 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
               targetKey = ref.source;
             }
             const existing = entryImportIndex.get(ref.localName);
-            if (existing && existing.targetKey === targetKey && existing.exportedName === ref.exportedName) {
+            if (existing && existing.targetKey === targetKey && existing.exportedName === ref.exportedName && (ref.isTypeOnly || !existing.isTypeOnly)) {
               continue;
             }
             const planned = plannedInjections.get(ref.localName);
@@ -8068,7 +8107,7 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
               break;
             }
             pending.push([ref.localName, { targetKey, exportedName: ref.exportedName }]);
-            required.push({ localName: ref.localName, exportedName: ref.exportedName, specifier });
+            required.push({ localName: ref.localName, exportedName: ref.exportedName, specifier, isTypeOnly: ref.isTypeOnly || undefined });
           }
           if (declinedEntry) {
             result.declined.set(spec.local, declinedEntry);
@@ -8088,6 +8127,8 @@ function prescanImportedReactiveFactories(entrySourceFile, filePath, result) {
 }
 function collectHelperModuleValueBindings(sf) {
   const local = new Set;
+  const localTypes = new Set;
+  const importedTypes = new Map;
   const imported = new Map;
   for (const stmt of sf.statements) {
     if (ts8.isVariableStatement(stmt)) {
@@ -8103,35 +8144,41 @@ function collectHelperModuleValueBindings(sf) {
       local.add(stmt.name.text);
       continue;
     }
+    if ((ts8.isTypeAliasDeclaration(stmt) || ts8.isInterfaceDeclaration(stmt)) && stmt.name) {
+      localTypes.add(stmt.name.text);
+      continue;
+    }
     if (ts8.isImportDeclaration(stmt)) {
-      if (stmt.importClause?.isTypeOnly)
-        continue;
       if (!ts8.isStringLiteral(stmt.moduleSpecifier))
         continue;
       const src = stmt.moduleSpecifier.text;
       if (src === "@barefootjs/client" || src === "@barefootjs/client/runtime")
         continue;
+      const wholeTypeOnly = stmt.importClause?.isTypeOnly === true;
       if (stmt.importClause?.name)
-        local.add(stmt.importClause.name.text);
+        (wholeTypeOnly ? localTypes : local).add(stmt.importClause.name.text);
       const namedBindings = stmt.importClause?.namedBindings;
       if (namedBindings && ts8.isNamedImports(namedBindings)) {
         for (const el of namedBindings.elements) {
-          if (el.isTypeOnly)
-            continue;
-          imported.set(el.name.text, { source: src, exportedName: (el.propertyName ?? el.name).text });
+          const entry = { source: src, exportedName: (el.propertyName ?? el.name).text };
+          if (wholeTypeOnly || el.isTypeOnly)
+            importedTypes.set(el.name.text, entry);
+          else
+            imported.set(el.name.text, entry);
         }
       }
       if (namedBindings && ts8.isNamespaceImport(namedBindings)) {
-        local.add(namedBindings.name.text);
+        (wholeTypeOnly ? localTypes : local).add(namedBindings.name.text);
       }
     }
   }
-  return { local, imported };
+  return { local, imported, localTypes, importedTypes };
 }
 function moduleCaptureCheck(fn, info, moduleBindings, selfName) {
   if (!fn.body)
-    return { captured: [], importedRefs: [] };
+    return { captured: [], importedRefs: [], importedTypeRefs: [] };
   const free = extractFreeIdentifiersFromNode(fn.body);
+  const freeTypes = extractFreeTypeIdentifiersFromNode(fn.body);
   const exclude = new Set(info.params);
   for (const b of info.localBindings)
     exclude.add(b);
@@ -8140,8 +8187,12 @@ function moduleCaptureCheck(fn, info, moduleBindings, selfName) {
   for (const p of REACTIVE_PRIMITIVES)
     exclude.add(p);
   exclude.add(selfName);
+  if (fn.typeParameters)
+    for (const p of fn.typeParameters)
+      exclude.add(p.name.text);
   const captured = [];
   const importedRefs = [];
+  const importedTypeRefs = [];
   for (const id of free) {
     if (exclude.has(id))
       continue;
@@ -8153,9 +8204,28 @@ function moduleCaptureCheck(fn, info, moduleBindings, selfName) {
     if (imp)
       importedRefs.push({ localName: id, source: imp.source, exportedName: imp.exportedName });
   }
+  for (const id of freeTypes) {
+    if (exclude.has(id))
+      continue;
+    if (free.has(id))
+      continue;
+    if (moduleBindings.localTypes.has(id) || moduleBindings.local.has(id)) {
+      captured.push(id);
+      continue;
+    }
+    const typeImp = moduleBindings.importedTypes.get(id);
+    if (typeImp) {
+      importedTypeRefs.push({ localName: id, source: typeImp.source, exportedName: typeImp.exportedName });
+      continue;
+    }
+    const valueImp = moduleBindings.imported.get(id);
+    if (valueImp)
+      importedRefs.push({ localName: id, source: valueImp.source, exportedName: valueImp.exportedName });
+  }
   captured.sort();
   importedRefs.sort((a, b) => a.localName < b.localName ? -1 : 1);
-  return { captured, importedRefs };
+  importedTypeRefs.sort((a, b) => a.localName < b.localName ? -1 : 1);
+  return { captured, importedRefs, importedTypeRefs };
 }
 function detectReactiveFactory(node, sourceFile, filePath) {
   if (!node.body || !node.name)
@@ -8494,20 +8564,44 @@ function rewriteFactoryCallsInSource(source, prescan) {
   if (edits.length === 0)
     return source;
   const importsBySpecifier = new Map;
+  const typeImportsBySpecifier = new Map;
   for (const f of inlinedFactories) {
     for (const r of f.requiredImports ?? []) {
-      let names = importsBySpecifier.get(r.specifier);
+      const bySpecifier = r.isTypeOnly ? typeImportsBySpecifier : importsBySpecifier;
+      let names = bySpecifier.get(r.specifier);
       if (!names) {
         names = new Map;
-        importsBySpecifier.set(r.specifier, names);
+        bySpecifier.set(r.specifier, names);
       }
       names.set(r.localName, r.exportedName);
     }
   }
-  if (importsBySpecifier.size > 0) {
-    const lines = [...importsBySpecifier].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([spec, names]) => {
+  for (const [spec, typeNames] of typeImportsBySpecifier) {
+    const valueNames = importsBySpecifier.get(spec);
+    if (!valueNames)
+      continue;
+    for (const local of [...typeNames.keys()]) {
+      if (valueNames.has(local))
+        typeNames.delete(local);
+    }
+    if (typeNames.size === 0)
+      typeImportsBySpecifier.delete(spec);
+  }
+  if (importsBySpecifier.size > 0 || typeImportsBySpecifier.size > 0) {
+    const buildLine = (names, keyword, spec) => {
       const specifiers = [...names].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([local, exported]) => exported === local ? local : `${exported} as ${local}`);
-      return `import { ${specifiers.join(", ")} } from '${spec}'`;
+      return `import ${keyword}{ ${specifiers.join(", ")} } from '${spec}'`;
+    };
+    const allSpecifiers = new Set([...importsBySpecifier.keys(), ...typeImportsBySpecifier.keys()]);
+    const lines = [...allSpecifiers].sort().flatMap((spec) => {
+      const out2 = [];
+      const valueNames = importsBySpecifier.get(spec);
+      if (valueNames)
+        out2.push(buildLine(valueNames, "", spec));
+      const typeNames = typeImportsBySpecifier.get(spec);
+      if (typeNames)
+        out2.push(buildLine(typeNames, "type ", spec));
+      return out2;
     });
     const at = factoryImportInsertionOffset(sourceFile);
     edits.push({ start: at, end: at, replacement: at === 0 ? lines.join(`
@@ -9198,6 +9292,20 @@ function resolveFreeRefs(node, env) {
 
 // src/to-locale-date-lowering.ts
 var TO_LOCALE_TZ_RE = /^(?:UTC|[+-](?:[01]\d|2[0-3]):[0-5]\d)$/;
+var tzProbeCache = new Map;
+function isBuildResolvableTimeZone(value) {
+  const cached = tzProbeCache.get(value);
+  if (cached !== undefined)
+    return cached;
+  let verified;
+  try {
+    verified = new Intl.DateTimeFormat("en-US", { timeZone: value }).resolvedOptions().timeZone === value;
+  } catch {
+    verified = false;
+  }
+  tzProbeCache.set(value, verified);
+  return verified;
+}
 var PROBE_UTC = new Date(Date.UTC(2001, 1, 3));
 var formatCache = new Map;
 var namesCache = new Map;
@@ -9436,7 +9544,7 @@ function matchToLocaleDateStringCall(callee, args, metadata) {
       return null;
     const value = String(prop.value.value);
     if (prop.key === "timeZone") {
-      if (!TO_LOCALE_TZ_RE.test(value))
+      if (!TO_LOCALE_TZ_RE.test(value) && !isBuildResolvableTimeZone(value))
         return null;
       tz = value;
     } else {
@@ -13008,13 +13116,19 @@ function collectEventHandlersFromIR(node) {
   });
   return handlers;
 }
-function traverseElements(node, visitor) {
+function traverseElements(node, visitor, stopAtReactiveConditionals = false) {
   walkIR(node, 0, {
     element: ({ node: el, scope: domDepth, descend }) => {
       visitor(el, domDepth);
       descend(domDepth + 1);
     },
-    loop: () => {}
+    loop: () => {},
+    ...stopAtReactiveConditionals ? {
+      conditional: ({ node: c, scope: domDepth, descend }) => {
+        if (!c.slotId)
+          descend(domDepth);
+      }
+    } : {}
   });
 }
 function collectConditionalBranchEvents(node) {
@@ -13029,7 +13143,7 @@ function collectConditionalBranchEvents(node) {
         });
       }
     }
-  });
+  }, true);
   return events;
 }
 function collectConditionalBranchRefs(node) {
@@ -13041,7 +13155,7 @@ function collectConditionalBranchRefs(node) {
         callback: el.ref
       });
     }
-  });
+  }, true);
   return refs;
 }
 function collectLoopChildRefs(node) {
@@ -13137,7 +13251,7 @@ function traverseForComponents(node, components, skipConditionals = false) {
     }
   });
 }
-function collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings) {
+function collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings, stopAtReactiveConditionals = false) {
   const texts = [];
   walkIR(node, false, {
     ...stopAt("loop", "async", "ifStatement"),
@@ -13156,13 +13270,14 @@ function collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings)
         ...expanded.freeIds !== undefined && { freeIdentifiers: expanded.freeIds }
       });
     },
-    conditional: ({ descend }) => {
-      descend(true);
+    conditional: ({ node: c, descend }) => {
+      if (!stopAtReactiveConditionals || !c.slotId)
+        descend(true);
     }
   });
   return texts;
 }
-function collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings) {
+function collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings, stopAtReactiveConditionals = false) {
   const attrs = [];
   traverseElements(node, (el) => {
     if (el.slotId) {
@@ -13189,7 +13304,7 @@ function collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings)
         });
       }
     }
-  });
+  }, stopAtReactiveConditionals);
   return attrs;
 }
 
@@ -14013,8 +14128,8 @@ function collectLoopChildBindings(children, ctx, siblingOffsets, loopParam, loop
   const bindings = emptyLoopChildBindings();
   for (const child of children) {
     bindings.events.push(...collectLoopChildEventsWithNesting(child));
-    bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, loopParam, loopParamBindings));
-    bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx, loopParam, loopParamBindings));
+    bindings.reactiveAttrs.push(...collectLoopChildReactiveAttrs(child, ctx, loopParam, loopParamBindings, true));
+    bindings.reactiveTexts.push(...collectLoopChildReactiveTexts(child, ctx, loopParam, loopParamBindings, true));
     bindings.refs.push(...collectLoopChildRefs(child));
     bindings.conditionals.push(...collectLoopChildConditionals(child, ctx, siblingOffsets, loopParam, loopParamBindings));
   }
@@ -14066,7 +14181,9 @@ function summarizeLoopChildBranch(node, ctx, siblingOffsets, loopParam, loopPara
     childComponents: collectConditionalBranchChildComponents(node),
     innerLoops: inner.length > 0 ? inner : undefined,
     conditionals: collectLoopChildConditionals(node, ctx, siblingOffsets, loopParam, loopParamBindings),
-    events: collectConditionalBranchEvents(node)
+    events: collectConditionalBranchEvents(node),
+    reactiveAttrs: collectLoopChildReactiveAttrs(node, ctx, loopParam, loopParamBindings, true),
+    reactiveTexts: node.type === "expression" ? [] : collectLoopChildReactiveTexts(node, ctx, loopParam, loopParamBindings, true)
   };
 }
 
@@ -17074,6 +17191,39 @@ function buildLoopChildConditionalsPlan(args) {
   }
   return plans;
 }
+function buildArmAttrsPlan(attrs, wrap) {
+  if (!attrs || attrs.length === 0)
+    return [];
+  const bySlot = new Map;
+  for (const attr of attrs) {
+    let bucket = bySlot.get(attr.childSlotId);
+    if (!bucket) {
+      bucket = [];
+      bySlot.set(attr.childSlotId, bucket);
+    }
+    bucket.push(attr);
+  }
+  const slots = [];
+  for (const [slotId, slotAttrs] of bySlot) {
+    slots.push({
+      slotId,
+      attrs: slotAttrs.map((attr) => ({
+        attrName: attr.attrName,
+        wrappedExpression: wrap(attr.expression),
+        meta: pickAttrMeta(attr)
+      }))
+    });
+  }
+  return slots;
+}
+function buildArmTextsPlan(texts, wrap) {
+  if (!texts || texts.length === 0)
+    return [];
+  return texts.map((text) => ({
+    slotId: text.slotId,
+    wrappedExpression: wrap(text.expression)
+  }));
+}
 function buildLoopChildArmPlan(args) {
   const { branch, wrap, loopParam, loopParamBindings } = args;
   return {
@@ -17099,7 +17249,8 @@ function buildLoopChildArmPlan(args) {
       loopParam,
       loopParamBindings
     }),
-    texts: []
+    attrs: buildArmAttrsPlan(branch.reactiveAttrs, wrap),
+    texts: buildArmTextsPlan(branch.reactiveTexts, wrap)
   };
 }
 
@@ -17127,49 +17278,20 @@ function buildReactiveEffectsPlan(args) {
       }))
     });
   }
-  const textSlotsInConditionals = new Set;
-  if (conditionals) {
-    for (const cond of conditionals) {
-      for (const text of texts) {
-        if (cond.whenTrueHtml.includes(`bf:${text.slotId}`) || cond.whenFalseHtml.includes(`bf:${text.slotId}`)) {
-          textSlotsInConditionals.add(text.slotId);
-        }
-      }
-    }
-  }
-  const outerTexts = [];
-  for (const text of texts) {
-    if (textSlotsInConditionals.has(text.slotId))
-      continue;
-    outerTexts.push({
-      slotId: text.slotId,
-      wrappedExpression: wrap(text.expression)
-    });
-  }
+  const outerTexts = texts.map((text) => ({
+    slotId: text.slotId,
+    wrappedExpression: wrap(text.expression)
+  }));
   const conditionalPlans = [];
   if (conditionals) {
     for (const cond of conditionals) {
-      const trueTexts = [];
-      const falseTexts = [];
-      for (const text of texts) {
-        if (!textSlotsInConditionals.has(text.slotId))
-          continue;
-        const wrapped = {
-          slotId: text.slotId,
-          wrappedExpression: wrap(text.expression)
-        };
-        if (cond.whenTrueHtml.includes(`bf:${text.slotId}`))
-          trueTexts.push(wrapped);
-        if (cond.whenFalseHtml.includes(`bf:${text.slotId}`))
-          falseTexts.push(wrapped);
-      }
       conditionalPlans.push({
         slotId: cond.slotId,
         wrappedCondition: wrap(cond.condition),
         whenTrueTemplateHtml: addCondAttrToTemplate(wrap(cond.whenTrueHtml), cond.slotId),
         whenFalseTemplateHtml: addCondAttrToTemplate(wrap(cond.whenFalseHtml), cond.slotId),
-        whenTrueArm: buildOuterArm(cond.whenTrue, trueTexts, wrap, loopParam, loopParamBindings, profileComponentName),
-        whenFalseArm: buildOuterArm(cond.whenFalse, falseTexts, wrap, loopParam, loopParamBindings, profileComponentName)
+        whenTrueArm: buildOuterArm(cond.whenTrue, wrap, loopParam, loopParamBindings, profileComponentName),
+        whenFalseArm: buildOuterArm(cond.whenFalse, wrap, loopParam, loopParamBindings, profileComponentName)
       });
     }
   }
@@ -17180,7 +17302,7 @@ function buildReactiveEffectsPlan(args) {
     profileComponentName
   };
 }
-function buildOuterArm(branch, texts, wrap, loopParam, loopParamBindings, profileComponentName) {
+function buildOuterArm(branch, wrap, loopParam, loopParamBindings, profileComponentName) {
   return {
     events: buildBranchEventBindingsPlan({
       events: branch.events,
@@ -17205,7 +17327,8 @@ function buildOuterArm(branch, texts, wrap, loopParam, loopParamBindings, profil
       loopParam,
       loopParamBindings
     }),
-    texts
+    attrs: buildArmAttrsPlan(branch.reactiveAttrs, wrap),
+    texts: buildArmTextsPlan(branch.reactiveTexts, wrap)
   };
 }
 function buildLoopReactiveEffectsPlan(elem, profileComponentName) {
@@ -17984,6 +18107,21 @@ function emitReactiveChildProps(lines, ctx) {
 }
 
 // src/ir-to-client-js/control-flow/stringify/loop-child-arm.ts
+function stringifyBranchReactiveAttrs(lines, plan, indent, pc) {
+  for (const slot of plan) {
+    const varName = `__ra_${varSlotId(slot.slotId)}`;
+    lines.push(`${indent}{ const ${varName} = qsa(__branchScope, '[bf="${slot.slotId}"]')`);
+    lines.push(`${indent}if (${varName}) {`);
+    for (const attr of slot.attrs) {
+      lines.push(`${indent}  __disposers.push(createDisposableEffect(() => {`);
+      for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta)) {
+        lines.push(`${indent}    ${stmt}`);
+      }
+      lines.push(`${indent}  }${profileBindingId(pc, slot.slotId)}))`);
+    }
+    lines.push(`${indent}} }`);
+  }
+}
 function stringifyBranchEventBindings(lines, plan, indent) {
   for (const slot of plan) {
     const v = varSlotId(slot.slotId);
@@ -18061,12 +18199,22 @@ function stringifyLoopChildArm(lines, arm, armIndent, pc) {
   stringifyBranchEventBindings(lines, arm.events, armIndent);
   stringifyBranchChildComponentInits(lines, arm.childComponents, armIndent);
   stringifyBranchInnerLoops(lines, arm.innerLoops, armIndent, pc);
-  stringifyLoopChildConditionals(lines, arm.nestedConditionals, armIndent, pc);
+  const hasDisposables = arm.attrs.length > 0 || arm.texts.length > 0 || arm.nestedConditionals.length > 0;
+  if (!hasDisposables)
+    return;
+  lines.push(`${armIndent}const __disposers = []`);
+  stringifyBranchReactiveAttrs(lines, arm.attrs, armIndent, pc);
+  for (const cond of arm.nestedConditionals) {
+    lines.push(`${armIndent}__disposers.push(createDisposableEffect(() => {`);
+    stringifyLoopChildConditional(lines, cond, `${armIndent}  `, pc);
+    lines.push(`${armIndent}}))`);
+  }
   for (const text of arm.texts) {
     const varName = `__rt_${varSlotId(text.slotId)}`;
-    lines.push(`${armIndent}{ const [${varName}] = $t(__branchScope, '${text.slotId}')`);
-    lines.push(`${armIndent}if (${varName}) createEffect(() => { ${varName}.textContent = String(${text.wrappedExpression}) }${profileBindingId(pc, text.slotId)}) }`);
+    lines.push(`${armIndent}let ${varName} = $t(__branchScope, '${text.slotId}')[0]`);
+    lines.push(`${armIndent}__disposers.push(createDisposableEffect(() => { ${varName} = __bfText(${varName}, ${text.wrappedExpression}) }${profileBindingId(pc, text.slotId)}))`);
   }
+  lines.push(`${armIndent}return () => __disposers.forEach(d => d())`);
 }
 
 // src/ir-to-client-js/control-flow/stringify/reactive-effects.ts
@@ -18111,29 +18259,15 @@ function emitOuterConditional(lines, indent, elVar, cond, pc) {
   lines.push(`${indent}insert(${elVar}, '${cond.slotId}', () => ${cond.wrappedCondition}, {`);
   lines.push(`${indent}  template: () => { const __slots = []; return { html: \`${cond.whenTrueTemplateHtml}\`, slots: __slots } },`);
   lines.push(`${indent}  bindEvents: (__branchScope, { isFirstRun: __bfFirstRun = false } = {}) => {`);
-  emitArmBody(lines, cond.whenTrueArm, armIndent, pc);
+  stringifyLoopChildArm(lines, cond.whenTrueArm, armIndent, pc);
   lines.push(`${indent}  }`);
   lines.push(`${indent}}, {`);
   lines.push(`${indent}  template: () => { const __slots = []; return { html: \`${cond.whenFalseTemplateHtml}\`, slots: __slots } },`);
   lines.push(`${indent}  bindEvents: (__branchScope, { isFirstRun: __bfFirstRun = false } = {}) => {`);
-  emitArmBody(lines, cond.whenFalseArm, armIndent, pc);
+  stringifyLoopChildArm(lines, cond.whenFalseArm, armIndent, pc);
   lines.push(`${indent}  }`);
   lines.push(`${indent}}${profileBindingId(pc, cond.slotId)})`);
 }
-function emitArmBody(lines, arm, armIndent, pc) {
-  stringifyBranchEventBindings(lines, arm.events, armIndent);
-  stringifyBranchChildComponentInits(lines, arm.childComponents, armIndent);
-  stringifyBranchInnerLoops(lines, arm.innerLoops, armIndent, pc);
-  stringifyLoopChildConditionals(lines, arm.nestedConditionals, armIndent, pc);
-  for (const text of arm.texts) {
-    emitArmText(lines, armIndent, text, pc);
-  }
-}
-function emitArmText(lines, indent, text, pc) {
-  const varName = `__rt_${varSlotId(text.slotId)}`;
-  lines.push(`${indent}{ const [${varName}] = $t(__branchScope, '${text.slotId}')`);
-  lines.push(`${indent}if (${varName}) createEffect(() => { ${varName}.textContent = String(${text.wrappedExpression}) }${profileBindingId(pc, text.slotId)}) }`);
-}
 
 // src/ir-to-client-js/control-flow/stringify/skeleton-paths.ts
 function pathExpr(base, path) {
@@ -18879,10 +19013,10 @@ function stringifyInsert(lines, plan, opts) {
 function emitArm(lines, arm, mode, armIndent, bodyIndent, profileComponentName) {
   lines.push(`${armIndent}template: () => { const __slots = []; return { html: \`${arm.templateHtml}\`, slots: __slots } },`);
   lines.push(`${armIndent}bindEvents: (__branchScope, { isFirstRun: __bfFirstRun = false } = {}) => {`);
-  emitArmBody2(lines, arm.body, mode, bodyIndent, profileComponentName);
+  emitArmBody(lines, arm.body, mode, bodyIndent, profileComponentName);
   lines.push(`${armIndent}}`);
 }
-function emitArmBody2(lines, body, mode, indent, profileComponentName) {
+function emitArmBody(lines, body, mode, indent, profileComponentName) {
   const bindingBfId = (slotId) => profileComponentName ? `, ${JSON.stringify(`${profileComponentName}#binding:${slotId}`)}` : "";
   const allSlotIds = new Set;
   for (const ev of body.events)
@@ -21064,7 +21198,7 @@ function pushDiagnostic(errors, seen, loc, method, receiverPath, isProp, typeNam
     return;
   seen.add(key);
   const receiver = isProp ? `prop '${receiverPath}'` : `'${receiverPath}'`;
-  const suggestion = method === "toLocaleDateString" && typeName === "Date" ? "Pass a literal locale and an explicit literal timeZone — .toLocaleDateString('ja-JP', { timeZone: 'UTC' }) (or a fixed '±HH:MM' offset) — to compile it to the format_date helper; for a runtime locale, resolve the pattern in your i18n layer and use formatDate(date, pattern, tz) from @barefootjs/client. Alternatively add /* @client */ or pre-compute server-side." : "Add /* @client */ to evaluate this expression on the client only, or pre-compute the value server-side.";
+  const suggestion = method === "toLocaleDateString" && typeName === "Date" ? "Pass a literal locale and an explicit literal timeZone — .toLocaleDateString('ja-JP', { timeZone: 'UTC' }), a fixed '±HH:MM' offset, or a canonical IANA zone ID like 'Asia/Tokyo' (exact case; #2344) — to compile it to the format_date helper; for a runtime locale, resolve the pattern in your i18n layer and use formatDate(date, pattern, tz) from @barefootjs/client. Alternatively add /* @client */ or pre-compute server-side." : "Add /* @client */ to evaluate this expression on the client only, or pre-compute the value server-side.";
   errors.push({
     code: ErrorCodes.UNSUPPORTED_JSX_PATTERN,
     severity: "error",
@@ -22701,27 +22835,31 @@ function resolveDangerousInnerHtml(element) {
   if (attr.clientOnly)
     return null;
   if (attr.value.kind !== "expression") {
-    return { kind: "dynamic", expr: "", loc: attr.loc };
+    return { kind: "unlowerable", expr: "", loc: attr.loc };
   }
   const parsed = attr.value.parsed ?? parseExpression(attr.value.expr.trim());
-  const html = staticHtmlLiteral(parsed);
-  if (html !== null)
-    return { kind: "static", html };
-  return { kind: "dynamic", expr: attr.value.expr, loc: attr.loc };
+  const value = htmlPropValue(parsed);
+  if (value === null)
+    return { kind: "unlowerable", expr: attr.value.expr, loc: attr.loc };
+  if (value.kind === "literal" && value.literalType === "string") {
+    return { kind: "static", html: value.value };
+  }
+  return {
+    kind: "dynamic",
+    valueExpr: stringifyParsedExpr(value),
+    valueParsed: value,
+    loc: attr.loc
+  };
 }
-function staticHtmlLiteral(parsed) {
+function htmlPropValue(parsed) {
   if (parsed.kind !== "object-literal")
     return null;
   if (parsed.properties.length !== 1)
     return null;
   const [prop] = parsed.properties;
-  if (prop.shorthand)
-    return null;
   if (prop.key !== "__html")
     return null;
-  if (prop.value.kind !== "literal" || prop.value.literalType !== "string")
-    return null;
-  return prop.value.value;
+  return prop.value;
 }
 var TEMPLATE_METACHAR_PATTERNS = {
   blade: /\{\{|\{!!|<\?|@\w|<\/?\s*x[-:]/,
@@ -22743,14 +22881,14 @@ function dangerousInnerHtmlMetacharViolation(html, adapterId) {
   return `the literal HTML contains a sequence ${adapterId}'s own template compiler would interpret (not inert text once spliced into the template)`;
 }
 function dangerousInnerHtmlDiagnostic(expr, loc, reason) {
-  const detail = reason ? ` — ${reason}.` : "";
+  const base = reason ? `dangerouslySetInnerHTML value cannot be lowered on this adapter — ${reason}` : "dangerouslySetInnerHTML requires an object literal with a single `__html` property (e.g. { __html: value }) — spreads, extra keys, and computed keys are not supported";
   return {
     code: "BF101",
     severity: "error",
-    message: `dangerouslySetInnerHTML requires a compile-time string literal __html value on template adapters (e.g. { __html: '...' })${expr ? `: ${expr.trim()}` : ""}${detail}`,
+    message: `${base}${expr ? `: ${expr.trim()}` : ""}`,
     loc,
     suggestion: {
-      message: "Dynamic or signal-derived HTML for dangerouslySetInnerHTML is only supported on Hono/CSR today (tracked separately: https://github.com/piconic-ai/barefootjs/issues/2215). Use an inline string literal, or defer it to the client with /* @client */ (e.g. dangerouslySetInnerHTML={/* @client */ { __html: expr }}) so hydration sets it instead of SSR."
+      message: "Pass an object literal { __html: value } with exactly one `__html` property (a string literal is spliced as trusted template text; a prop/signal value is lowered through the adapter's raw-output sink). To force it onto the client instead of SSR, use /* @client */ (e.g. dangerouslySetInnerHTML={/* @client */ { __html: expr }}) so hydration sets it."
     }
   };
 }

package/dist/ir-to-client-js/collect-elements.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"collect-elements.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/collect-elements.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,MAAM,EAAoC,KAAK,MAAM,EAAmC,MAAM,aAAa,CAAA;AACzH,OAAO,KAAK,EAAE,eAAe,EAA+H,iBAAiB,EAA0B,oBAAoB,EAAc,UAAU,EAAE,MAAM,YAAY,CAAA;AAyGvQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CA0C7E;AAyBD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB;AAED,4DAA4D;AAC5D,eAAO,MAAM,sBAAsB,EAAE,wBAIpC,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EAAE,EACf,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,cAAc,CAAC,EAAE,MAAM,EACvB,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,CAAC,EAAE,wBAAwB,GACjC,UAAU,EAAE,CAyId;AAqKD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,eAAe,EACpB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,iBAAiB,UAAQ,GACxB,IAAI,CA+PN;AA+WD;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,GAAG,EAAE,eAAe,EACpB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,SAAS,OAAO,aAAa,EAAE,gBAAgB,EAAE,GAAG,SAAS,GAC/E,iBAAiB,CAUnB;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,eAAe,EACpB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,SAAS,CAAC,EAAE,MAAM,EAClB,iBAAiB,CAAC,EAAE,SAAS,OAAO,aAAa,EAAE,gBAAgB,EAAE,GACpE,oBAAoB,EAAE,CA4DxB"}
+{"version":3,"file":"collect-elements.d.ts","sourceRoot":"","sources":["../../src/ir-to-client-js/collect-elements.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,KAAK,MAAM,EAAoC,KAAK,MAAM,EAAmC,MAAM,aAAa,CAAA;AACzH,OAAO,KAAK,EAAE,eAAe,EAA+H,iBAAiB,EAA0B,oBAAoB,EAAc,UAAU,EAAE,MAAM,YAAY,CAAA;AAyGvQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CA0C7E;AAyBD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;;OAKG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B;;;;;OAKG;IACH,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB;AAED,4DAA4D;AAC5D,eAAO,MAAM,sBAAsB,EAAE,wBAIpC,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EAAE,EACf,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,cAAc,CAAC,EAAE,MAAM,EACvB,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,CAAC,EAAE,wBAAwB,GACjC,UAAU,EAAE,CAyId;AAqKD;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,eAAe,EACpB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,iBAAiB,UAAQ,GACxB,IAAI,CA+PN;AA+WD;;;;;;;;;;GAUG;AAEH;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,SAAS,MAAM,EAAE,EAC3B,GAAG,EAAE,eAAe,EACpB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,SAAS,OAAO,aAAa,EAAE,gBAAgB,EAAE,GAAG,SAAS,GAC/E,iBAAiB,CAenB;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,eAAe,EACpB,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,EACrC,SAAS,CAAC,EAAE,MAAM,EAClB,iBAAiB,CAAC,EAAE,SAAS,OAAO,aAAa,EAAE,gBAAgB,EAAE,GACpE,oBAAoB,EAAE,CA4DxB"}