@barefootjs/jsx 0.10.0 → 0.11.0

package/dist/index.js

@@ -232,6 +232,11 @@ function keyAttrName(loopDepth) {
 function varSlotId(slotId) {
   return slotId.startsWith("^") ? slotId.slice(1) : slotId;
 }
+function profileBindingId(componentName, slotId) {
+  if (!componentName || slotId === "?")
+    return "";
+  return `, ${JSON.stringify(`${componentName}#binding:${slotId}`)}`;
+}
 function templatePartsToJsExpr(parts, opts) {
   let result = "`";
   for (const part of parts) {
@@ -312,6 +317,10 @@ function wrapHandlerInBlock(handler) {
   }
   return trimmed;
 }
+function wrapHandlerForTurn(handler, handlerId, loc) {
+  const idArg = loc ? `${JSON.stringify(handlerId)}, ${JSON.stringify(loc)}` : JSON.stringify(handlerId);
+  return `(...__bfa) => { beginTurn(${idArg}); try { return (${handler.trim()})(...__bfa) } finally { endTurn() } }`;
+}
 function emitRefCall(callback, elementVar) {
   const trimmed = callback.trim();
   const isBareIdent = /^[a-zA-Z_$][\w$]*$/.test(trimmed);
@@ -5373,6 +5382,40 @@ function extractArrowBodyExpression(source) {
     return null;
   return expr.body.getText(sf).trim();
 }
+function cssKebabCase(name) {
+  return name.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase()).replace(/^ms-/, "-ms-");
+}
+function parseStyleObjectEntries(source) {
+  const sf = ts8.createSourceFile("__style__.ts", `(${source})`, ts8.ScriptTarget.Latest, true);
+  const stmt = sf.statements[0];
+  if (!stmt || !ts8.isExpressionStatement(stmt) || sf.statements.length !== 1)
+    return null;
+  let expr = stmt.expression;
+  while (ts8.isParenthesizedExpression(expr))
+    expr = expr.expression;
+  if (!ts8.isObjectLiteralExpression(expr))
+    return null;
+  const entries = [];
+  for (const prop of expr.properties) {
+    if (!ts8.isPropertyAssignment(prop))
+      return null;
+    let key;
+    if (ts8.isIdentifier(prop.name))
+      key = prop.name.text;
+    else if (ts8.isStringLiteral(prop.name))
+      key = prop.name.text;
+    else
+      return null;
+    const cssKey = cssKebabCase(key);
+    const init = prop.initializer;
+    if (ts8.isStringLiteral(init) || ts8.isNoSubstitutionTemplateLiteral(init)) {
+      entries.push({ cssKey, kind: "literal", value: init.text });
+    } else {
+      entries.push({ cssKey, kind: "expr", expr: init.getText(sf).trim() });
+    }
+  }
+  return entries.length > 0 ? entries : null;
+}
 function parseExpression(expr) {
   const trimmed = expr.trim();
   if (!trimmed) {
@@ -9221,7 +9264,7 @@ function tryStaticStyleObjectToCss(expr) {
       return null;
     if (!ts11.isStringLiteral(prop.initializer))
       return null;
-    const key = prop.name.text.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+    const key = cssKebabCase(prop.name.text);
     parts.push(`${key}:${prop.initializer.text}`);
   }
   return parts.join(";");
@@ -11331,7 +11374,9 @@ var RUNTIME_IMPORT_CANDIDATES = [
   "upsertChildItem",
   "__slot",
   "__bfSlot",
-  "__bfText"
+  "__bfText",
+  "beginTurn",
+  "endTurn"
 ];
 var RUNTIME_MODULE = "@barefootjs/client/runtime";
 var IMPORT_PLACEHOLDER = "/* __BAREFOOTJS_DOM_IMPORTS__ */";
@@ -12520,7 +12565,8 @@ function buildDeclarationEmitPlan(decl, ctx, lookups) {
       return {
         kind: "memo",
         name: decl.info.name,
-        computationExpr: decl.info.computation
+        computationExpr: decl.info.computation,
+        bfId: ctx.profile ? `${ctx.componentName}#memo:${decl.info.name}` : undefined
       };
     case "function": {
       const fn = decl.info;
@@ -12538,13 +12584,18 @@ function buildDeclarationEmitPlan(decl, ctx, lookups) {
   }
 }
 function buildSignalPlan(signal, ctx, lookups) {
+  const controlledEffect = buildControlledSignalEffect(signal, lookups);
+  if (controlledEffect && ctx.profile) {
+    controlledEffect.bfId = `${ctx.componentName}#effect:controlled:${signal.setter}`;
+  }
   return {
     kind: "signal",
     getter: signal.getter,
     setter: signal.setter,
     initialValueExpr: resolveSignalInitialValue(signal, ctx, lookups),
-    controlledEffect: buildControlledSignalEffect(signal, lookups),
-    branchCondition: signal.branchCondition
+    controlledEffect,
+    branchCondition: signal.branchCondition,
+    bfId: ctx.profile ? `${ctx.componentName}#signal:${signal.getter}` : undefined
   };
 }
 function resolveSignalInitialValue(signal, ctx, lookups) {
@@ -12608,25 +12659,29 @@ function emitConstant(lines, plan) {
     lines.push(`  ${plan.keyword} ${plan.name}`);
   }
 }
+function bfIdArg(bfId) {
+  return bfId ? `, ${JSON.stringify(bfId)}` : "";
+}
 function emitSignal(lines, plan) {
+  const id = bfIdArg(plan.bfId);
   if (plan.branchCondition) {
     if (plan.setter) {
       lines.push(`  let ${plan.getter}, ${plan.setter}`);
       lines.push(`  if (${plan.branchCondition}) {`);
-      lines.push(`    ;[${plan.getter}, ${plan.setter}] = createSignal(${plan.initialValueExpr})`);
+      lines.push(`    ;[${plan.getter}, ${plan.setter}] = createSignal(${plan.initialValueExpr}${id})`);
       lines.push(`  }`);
     } else {
       lines.push(`  let ${plan.getter}`);
       lines.push(`  if (${plan.branchCondition}) {`);
-      lines.push(`    ;[${plan.getter}] = createSignal(${plan.initialValueExpr})`);
+      lines.push(`    ;[${plan.getter}] = createSignal(${plan.initialValueExpr}${id})`);
       lines.push(`  }`);
     }
     return;
   }
   if (plan.setter) {
-    lines.push(`  const [${plan.getter}, ${plan.setter}] = createSignal(${plan.initialValueExpr})`);
+    lines.push(`  const [${plan.getter}, ${plan.setter}] = createSignal(${plan.initialValueExpr}${id})`);
   } else {
-    lines.push(`  const [${plan.getter}] = createSignal(${plan.initialValueExpr})`);
+    lines.push(`  const [${plan.getter}] = createSignal(${plan.initialValueExpr}${id})`);
   }
   if (plan.controlledEffect) {
     emitControlledEffect(lines, plan.controlledEffect);
@@ -12636,10 +12691,10 @@ function emitControlledEffect(lines, plan) {
   lines.push(`  createEffect(() => {`);
   lines.push(`    const __val = ${plan.accessorExpr}`);
   lines.push(`    if (__val !== undefined) ${plan.setter}(__val)`);
-  lines.push(`  })`);
+  lines.push(`  }${bfIdArg(plan.bfId)})`);
 }
 function emitMemo(lines, plan) {
-  lines.push(`  const ${plan.name} = createMemo(${plan.computationExpr})`);
+  lines.push(`  const ${plan.name} = createMemo(${plan.computationExpr}${bfIdArg(plan.bfId)})`);
 }
 function emitFunction(lines, plan) {
   const asyncKw = plan.isAsync ? "async " : "";
@@ -12851,13 +12906,14 @@ function collectConditionalSlotIds(ctx) {
 
 // src/ir-to-client-js/phases/effects-and-on-mounts.ts
 function emitEffectsAndOnMounts(lines, ctx) {
-  for (const effect of ctx.effects) {
+  ctx.effects.forEach((effect, i) => {
+    const idArg = ctx.profile ? `, ${JSON.stringify(`${ctx.componentName}#effect:${effect.captureName ?? effect.loc?.start.line ?? i}`)}` : "";
     if (effect.captureName) {
-      lines.push(`  const ${effect.captureName} = createEffect(${effect.body})`);
+      lines.push(`  const ${effect.captureName} = createEffect(${effect.body}${idArg})`);
     } else {
-      lines.push(`  createEffect(${effect.body})`);
+      lines.push(`  createEffect(${effect.body}${idArg})`);
     }
-  }
+  });
   for (const onMount of ctx.onMounts) {
     lines.push(`  onMount(${onMount.body})`);
   }
@@ -12870,7 +12926,7 @@ function emitEventHandlers(lines, ctx, conditionalSlotIds) {
       continue;
     for (const event of elem.events) {
       const eventName = toDomEventName(event.name);
-      const wrappedHandler = wrapHandlerInBlock(event.handler);
+      const wrappedHandler = ctx.profile ? wrapHandlerForTurn(event.handler, `${ctx.componentName}#handler:${elem.slotId}:${event.name}`) : wrapHandlerInBlock(event.handler);
       if (elem.slotId === "__scope") {
         lines.push(`  if (__scope) __scope.addEventListener('${eventName}', ${wrappedHandler})`);
       } else {
@@ -13002,8 +13058,8 @@ function emitRestAttrApplications(lines, ctx) {
 }
 
 // src/ir-to-client-js/control-flow/stringify/event-listener.ts
-function emitListenerLine(lines, indent, elementVar, eventName, handler, mode = "dom") {
-  const wrapped = wrapHandlerInBlock(handler);
+function emitListenerLine(lines, indent, elementVar, eventName, handler, mode = "dom", turnId) {
+  const wrapped = turnId ? wrapHandlerForTurn(handler, turnId) : wrapHandlerInBlock(handler);
   const name = mode === "dom" ? toDomEventName(eventName) : eventName;
   lines.push(`${indent}if (${elementVar}) ${elementVar}.addEventListener('${name}', ${wrapped})`);
 }
@@ -13432,7 +13488,7 @@ function wrapAttrValueExpression(value, wrap) {
   }
 }
 function buildBranchEventBindingsPlan(args) {
-  const { events, wrap } = args;
+  const { events, wrap, profileComponentName: pc } = args;
   if (!events || events.length === 0)
     return [];
   const eventsBySlot = new Map;
@@ -13444,7 +13500,8 @@ function buildBranchEventBindingsPlan(args) {
     }
     bucket.push({
       eventName: ev.eventName,
-      wrappedHandler: wrap(ev.handler)
+      wrappedHandler: wrap(ev.handler),
+      turnId: pc ? `${pc}#handler:${ev.slotId}:${ev.eventName}` : undefined
     });
   }
   const slots = [];
@@ -13548,6 +13605,7 @@ function buildBranchInnerLoopsPlan(args) {
     plan.push({
       uidSuffix: `br_${i}`,
       markerId: inner.markerId,
+      slotId: csl ?? "?",
       containerExpr,
       arrayExpr: wrapOuter(inner.array),
       keyFn: loopKeyFn(inner),
@@ -13633,7 +13691,7 @@ function buildLoopChildArmPlan(args) {
 
 // src/ir-to-client-js/control-flow/plan/build-reactive-effects.ts
 function buildReactiveEffectsPlan(args) {
-  const { attrs, texts, conditionals, loopParam, loopParamBindings } = args;
+  const { attrs, texts, conditionals, loopParam, loopParamBindings, profileComponentName } = args;
   const wrap = (expr) => wrapLoopParamAsAccessor(expr, loopParam, loopParamBindings);
   const attrsBySlot = new Map;
   for (const attr of attrs) {
@@ -13696,22 +13754,24 @@ function buildReactiveEffectsPlan(args) {
         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),
-        whenFalseArm: buildOuterArm(cond.whenFalse, falseTexts, wrap, loopParam, loopParamBindings)
+        whenTrueArm: buildOuterArm(cond.whenTrue, trueTexts, wrap, loopParam, loopParamBindings, profileComponentName),
+        whenFalseArm: buildOuterArm(cond.whenFalse, falseTexts, wrap, loopParam, loopParamBindings, profileComponentName)
       });
     }
   }
   return {
     attrSlots,
     outerTexts,
-    conditionals: conditionalPlans
+    conditionals: conditionalPlans,
+    profileComponentName
   };
 }
-function buildOuterArm(branch, texts, wrap, loopParam, loopParamBindings) {
+function buildOuterArm(branch, texts, wrap, loopParam, loopParamBindings, profileComponentName) {
   return {
     events: buildBranchEventBindingsPlan({
       events: branch.events,
-      wrap
+      wrap,
+      profileComponentName
     }),
     childComponents: buildBranchChildComponentInitsPlan({
       components: branch.childComponents,
@@ -13734,13 +13794,14 @@ function buildOuterArm(branch, texts, wrap, loopParam, loopParamBindings) {
     texts
   };
 }
-function buildLoopReactiveEffectsPlan(elem) {
+function buildLoopReactiveEffectsPlan(elem, profileComponentName) {
   return buildReactiveEffectsPlan({
     attrs: elem.bindings.reactiveAttrs,
     texts: elem.bindings.reactiveTexts,
     conditionals: elem.bindings.conditionals,
     loopParam: elem.param,
-    loopParamBindings: elem.paramBindings
+    loopParamBindings: elem.paramBindings,
+    profileComponentName
   });
 }
 
@@ -13802,6 +13863,7 @@ function buildInnerLoopsPlan(args) {
     plan.push({
       uidSuffix,
       markerId: inner.markerId,
+      slotId: inner.containerSlotId ?? "?",
       containerExpr,
       arrayExpr,
       arraySrc: inner.array,
@@ -13896,7 +13958,7 @@ function buildStaticEmit(inner, level) {
 }
 
 // src/ir-to-client-js/control-flow/plan/build-composite-loop.ts
-function buildTopLevelCompositePlan(elem) {
+function buildTopLevelCompositePlan(elem, profileComponentName) {
   const nestedComps = elem.nestedComponents;
   const depthLevels = buildDepthLevels(elem.innerLoops ?? [], nestedComps, elem.bindings.events);
   const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(elem.param, elem.paramBindings);
@@ -13929,15 +13991,18 @@ function buildTopLevelCompositePlan(elem) {
       texts: elem.bindings.reactiveTexts,
       conditionals: elem.bindings.conditionals,
       loopParam: elem.param,
-      loopParamBindings: elem.paramBindings
+      loopParamBindings: elem.paramBindings,
+      profileComponentName
     }) : null,
     branchClearChildren: false,
     topIndent: "  ",
     bodyIndent: "    ",
-    bodyIsMultiRoot: elem.bodyIsMultiRoot ?? false
+    bodyIsMultiRoot: elem.bodyIsMultiRoot ?? false,
+    profileLoopId: profileComponentName ? `${profileComponentName}#binding:${elem.slotId}` : undefined,
+    profileComponentName
   };
 }
-function buildBranchCompositePlan(loop, cv) {
+function buildBranchCompositePlan(loop, cv, profileComponentName) {
   const nestedComps = loop.nestedComponents;
   const innerLoops = loop.innerLoops ?? [];
   const childEvents = loop.bindings.events;
@@ -13972,12 +14037,15 @@ function buildBranchCompositePlan(loop, cv) {
       texts: loop.bindings.reactiveTexts,
       conditionals: loop.bindings.conditionals,
       loopParam: loop.param,
-      loopParamBindings: loop.paramBindings
+      loopParamBindings: loop.paramBindings,
+      profileComponentName
     }) : null,
     branchClearChildren: true,
     topIndent: "      ",
     bodyIndent: "        ",
-    bodyIsMultiRoot: loop.bodyIsMultiRoot ?? false
+    bodyIsMultiRoot: loop.bodyIsMultiRoot ?? false,
+    profileLoopId: profileComponentName ? `${profileComponentName}#binding:${loop.containerSlotId}` : undefined,
+    profileComponentName
   };
 }
 function filterCondCompsOut(outerComps, conditionals) {
@@ -14002,11 +14070,12 @@ function hasReactiveBranch(loop) {
 }
 
 // src/ir-to-client-js/control-flow/plan/build-event-delegation.ts
-function buildDynamicLoopDelegationPlan(elem) {
+function buildDynamicLoopDelegationPlan(elem, profileComponentName) {
   return {
     kind: "event-delegation",
     containerVar: `_${varSlotId(elem.slotId)}`,
     events: elem.bindings.events,
+    profileComponentName,
     itemLookup: buildKeyedOrIndexLookup({
       array: buildChainedArrayExpr(elem),
       param: elem.param,
@@ -14016,11 +14085,12 @@ function buildDynamicLoopDelegationPlan(elem) {
     })
   };
 }
-function buildBranchLoopDelegationPlan(loop, cv) {
+function buildBranchLoopDelegationPlan(loop, cv, profileComponentName) {
   return {
     kind: "event-delegation",
     containerVar: `__loop_${cv}`,
     events: loop.bindings.events,
+    profileComponentName,
     itemLookup: buildKeyedOrIndexLookup({
       array: buildChainedArrayExpr(loop),
       param: loop.param,
@@ -14030,11 +14100,12 @@ function buildBranchLoopDelegationPlan(loop, cv) {
     })
   };
 }
-function buildStaticArrayDelegationPlan(elem) {
+function buildStaticArrayDelegationPlan(elem, profileComponentName) {
   return {
     kind: "event-delegation",
     containerVar: `_${varSlotId(elem.slotId)}`,
     events: elem.bindings.events,
+    profileComponentName,
     itemLookup: {
       kind: "static-index",
       arrayExpr: buildChainedArrayExpr(elem),
@@ -14068,14 +14139,14 @@ function buildKeyedOrIndexLookup(args) {
 }
 
 // src/ir-to-client-js/control-flow/plan/build-branch-loop.ts
-function buildBranchLoopPlan(loop) {
+function buildBranchLoopPlan(loop, profileComponentName) {
   const containerSlotId = loop.containerSlotId;
   const cv = varSlotId(containerSlotId);
   const containerVar = `__loop_${cv}`;
   if (loop.useElementReconciliation && (loop.nestedComponents?.length || loop.innerLoops?.length)) {
     const composite = {
       kind: "composite",
-      composite: buildBranchCompositePlan(loop, cv),
+      composite: buildBranchCompositePlan(loop, cv, profileComponentName),
       containerSlotId,
       containerVar
     };
@@ -14100,11 +14171,13 @@ function buildBranchLoopPlan(loop) {
       texts: loop.bindings.reactiveTexts,
       conditionals: loop.bindings.conditionals,
       loopParam: loop.param,
-      loopParamBindings: loop.paramBindings
+      loopParamBindings: loop.paramBindings,
+      profileComponentName
     }) : null,
-    eventDelegation: buildBranchLoopDelegationPlan(loop, cv),
+    eventDelegation: buildBranchLoopDelegationPlan(loop, cv, profileComponentName),
     childRefs: buildChildRefBindings(loop.bindings.refs, loop.param, loop.paramBindings),
-    bodyIsMultiRoot: loop.bodyIsMultiRoot ?? false
+    bodyIsMultiRoot: loop.bodyIsMultiRoot ?? false,
+    profileLoopId: profileComponentName ? `${profileComponentName}#binding:${containerSlotId}` : undefined
   };
   return plan;
 }
@@ -14117,6 +14190,7 @@ function buildInsertPlan(elem, options) {
     slotId: elem.slotId,
     condition: elem.condition,
     eventNameMode: options.eventNameMode,
+    profileComponentName: options.profileComponentName,
     arms: [
       buildArm(elem.whenTrueHtml, elem.slotId, elem.whenTrue, options),
       buildArm(elem.whenFalseHtml, elem.slotId, elem.whenFalse, options)
@@ -14130,11 +14204,13 @@ function buildArm(html, slotId, branch, options) {
   };
 }
 function buildArmBody(branch, options) {
+  const pc = options.profileComponentName;
   return {
     events: branch.events.map((e) => ({
       slotId: e.slotId,
       eventName: e.eventName,
-      handler: e.handler
+      handler: e.handler,
+      turnId: pc ? `${pc}#handler:${e.slotId}:${e.eventName}` : undefined
     })),
     refs: branch.refs.map((r) => ({
       slotId: r.slotId,
@@ -14150,12 +14226,17 @@ function buildArmBody(branch, options) {
       slotId: t.slotId,
       expression: t.expression
     })),
-    loops: branch.loops.map(buildBranchLoopPlan),
-    conditionals: branch.conditionals.map((c) => buildInsertPlan(c, { scope: { kind: "branchScope" }, eventNameMode: options.eventNameMode }))
+    loops: branch.loops.map((l) => buildBranchLoopPlan(l, pc)),
+    conditionals: branch.conditionals.map((c) => buildInsertPlan(c, { scope: { kind: "branchScope" }, eventNameMode: options.eventNameMode, profileComponentName: pc }))
   };
 }
 
 // src/ir-to-client-js/emit-reactive.ts
+function bindingIdArg(ctx, slotId) {
+  if (!ctx.profile || !slotId)
+    return "";
+  return `, ${JSON.stringify(`${ctx.componentName}#binding:${slotId}`)}`;
+}
 function emitAttrUpdate(target, attrName, expression, meta) {
   const htmlName = toHtmlAttrName(attrName);
   if (attrName === "dangerouslySetInnerHTML" || htmlName === "dangerouslySetInnerHTML") {
@@ -14227,6 +14308,7 @@ function emitDynamicTextUpdates(lines, ctx) {
         const v = varSlotId(elem.slotId);
         lines.push(`  let __anchor_${v} = _${v}`);
       }
+      const __textSlot = (normalElems[0] ?? conditionalElems[0])?.slotId;
       lines.push(`  createEffect(() => {`);
       if (normalElems.length > 0) {
         lines.push(`    const __val = ${expr}`);
@@ -14248,7 +14330,7 @@ function emitDynamicTextUpdates(lines, ctx) {
           lines.push(`    __bfText(__el_${v}, __val)`);
         }
       }
-      lines.push(`  })`);
+      lines.push(`  }${bindingIdArg(ctx, __textSlot)})`);
       lines.push("");
     }
   }
@@ -14258,7 +14340,7 @@ function emitClientOnlyExpressions(lines, ctx) {
     lines.push(`  // @client: ${elem.slotId}`);
     lines.push(`  createEffect(() => {`);
     lines.push(`    updateClientMarker(__scope, '${elem.slotId}', ${elem.expression})`);
-    lines.push(`  })`);
+    lines.push(`  }${bindingIdArg(ctx, elem.slotId)})`);
     lines.push("");
   }
 }
@@ -14282,7 +14364,7 @@ function emitReactiveAttributeUpdates(lines, ctx) {
         }
       }
       lines.push(`    }`);
-      lines.push(`  })`);
+      lines.push(`  }${bindingIdArg(ctx, slotId)})`);
       lines.push("");
     }
   }
@@ -14328,7 +14410,7 @@ function emitReactivePropBindings(lines, ctx) {
       }
       lines.push(`    }`);
     }
-    lines.push(`  })`);
+    lines.push(`  }${bindingIdArg(ctx, ctx.reactiveProps[0]?.slotId)})`);
   }
 }
 function emitReactiveChildProps(lines, ctx) {
@@ -14358,7 +14440,7 @@ function emitReactiveChildProps(lines, ctx) {
       }
       lines.push(`    }`);
     }
-    lines.push(`  })`);
+    lines.push(`  }${bindingIdArg(ctx, ctx.reactiveChildProps[0]?.slotId ?? undefined)})`);
   }
 }
 
@@ -14504,7 +14586,7 @@ function stringifyBranchEventBindings(lines, plan, indent) {
     const v = varSlotId(slot.slotId);
     lines.push(`${indent}{ const _${v} = qsa(__branchScope, '[bf="${slot.slotId}"]')`);
     for (const ev of slot.listeners) {
-      emitListenerLine(lines, `${indent}  `, `_${v}`, ev.eventName, ev.wrappedHandler);
+      emitListenerLine(lines, `${indent}  `, `_${v}`, ev.eventName, ev.wrappedHandler, "dom", ev.turnId);
     }
     lines.push(`${indent}}`);
   }
@@ -14514,7 +14596,7 @@ function stringifyBranchChildComponentInits(lines, plan, indent) {
     lines.push(`${indent}{ let __c = qsa(__branchScope, ${init.selector}); if (!__c) { const __ph = __branchScope.querySelector('[${DATA_BF_PH}="${init.placeholderId}"]'); if (__ph) { __c = createComponent('${nameForRegistryRef(init.name)}', ${init.propsExpr}); __ph.replaceWith(__c) } } if (__c) initChild('${nameForRegistryRef(init.name)}', __c, ${init.propsExpr}) }`);
   }
 }
-function stringifyBranchInnerLoops(lines, plan, indent) {
+function stringifyBranchInnerLoops(lines, plan, indent, pc) {
   for (const inner of plan) {
     const uid = inner.uidSuffix;
     lines.push(`${indent}{ const __bic${uid} = ${inner.containerExpr}`);
@@ -14535,48 +14617,49 @@ function stringifyBranchInnerLoops(lines, plan, indent) {
       emitComponentAndEventSetup(lines, `${indent}  `, `__bel${uid}`, [...inner.legacyComponents], [...inner.legacyEvents], inner.outerLoopParam, inner.outerLoopParamBindings);
     }
     for (const text of inner.reactiveTexts) {
+      const bf = profileBindingId(pc, text.slotId);
       if (text.insideConditional) {
-        lines.push(`${indent}  createEffect(() => { const [__rt] = $t(__bel${uid}, '${text.slotId}'); if (__rt) __rt.textContent = String(${text.wrappedExpression}) })`);
+        lines.push(`${indent}  createEffect(() => { const [__rt] = $t(__bel${uid}, '${text.slotId}'); if (__rt) __rt.textContent = String(${text.wrappedExpression}) }${bf})`);
       } else {
         lines.push(`${indent}  { const [__rt] = $t(__bel${uid}, '${text.slotId}')`);
-        lines.push(`${indent}  if (__rt) createEffect(() => { __rt.textContent = String(${text.wrappedExpression}) }) }`);
+        lines.push(`${indent}  if (__rt) createEffect(() => { __rt.textContent = String(${text.wrappedExpression}) }${bf}) }`);
       }
     }
     if (inner.nestedConditionals.length > 0) {
-      stringifyLoopChildConditionals(lines, inner.nestedConditionals, `${indent}  `);
+      stringifyLoopChildConditionals(lines, inner.nestedConditionals, `${indent}  `, pc);
     }
     lines.push(`${indent}  return __bel${uid}`);
-    lines.push(`${indent}}, '${inner.markerId}') }`);
+    lines.push(`${indent}}, '${inner.markerId}'${profileBindingId(pc, inner.slotId)}) }`);
   }
 }
-function stringifyLoopChildConditionals(lines, conditionals, indent) {
+function stringifyLoopChildConditionals(lines, conditionals, indent, pc) {
   for (const cond of conditionals) {
-    stringifyLoopChildConditional(lines, cond, indent);
+    stringifyLoopChildConditional(lines, cond, indent, pc);
   }
 }
-function stringifyLoopChildConditional(lines, cond, indent) {
+function stringifyLoopChildConditional(lines, cond, indent, pc) {
   const armIndent = `${indent}    `;
   lines.push(`${indent}insert(${cond.scopeVar}, '${cond.slotId}', () => ${cond.wrappedCondition}, {`);
   lines.push(`${indent}  template: () => { const __slots = []; return { html: \`${cond.whenTrueTemplateHtml}\`, slots: __slots } },`);
   lines.push(`${indent}  bindEvents: (__branchScope, { isFirstRun: __bfFirstRun = false } = {}) => {`);
-  stringifyLoopChildArm(lines, cond.whenTrueArm, armIndent);
+  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 } = {}) => {`);
-  stringifyLoopChildArm(lines, cond.whenFalseArm, armIndent);
+  stringifyLoopChildArm(lines, cond.whenFalseArm, armIndent, pc);
   lines.push(`${indent}  }`);
-  lines.push(`${indent}})`);
+  lines.push(`${indent}}${profileBindingId(pc, cond.slotId)})`);
 }
-function stringifyLoopChildArm(lines, arm, armIndent) {
+function stringifyLoopChildArm(lines, arm, armIndent, pc) {
   stringifyBranchEventBindings(lines, arm.events, armIndent);
   stringifyBranchChildComponentInits(lines, arm.childComponents, armIndent);
-  stringifyBranchInnerLoops(lines, arm.innerLoops, armIndent);
-  stringifyLoopChildConditionals(lines, arm.nestedConditionals, armIndent);
+  stringifyBranchInnerLoops(lines, arm.innerLoops, armIndent, pc);
+  stringifyLoopChildConditionals(lines, arm.nestedConditionals, armIndent, pc);
   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}) }) }`);
+    lines.push(`${armIndent}if (${varName}) createEffect(() => { ${varName}.textContent = String(${text.wrappedExpression}) }${profileBindingId(pc, text.slotId)}) }`);
   }
 }
 
@@ -14584,6 +14667,8 @@ function stringifyLoopChildArm(lines, arm, armIndent) {
 function stringifyReactiveEffects(lines, plan, opts) {
   const { indent, elVar, bodyIsMultiRoot } = opts;
   const lookup = bodyIsMultiRoot ? "qsaItem" : "qsa";
+  const pc = plan.profileComponentName;
+  const bindingBfId = (slotId) => profileBindingId(pc, slotId);
   for (const slot of plan.attrSlots) {
     const varName = `__ra_${varSlotId(slot.slotId)}`;
     lines.push(`${indent}{ const ${varName} = ${lookup}(${elVar}, '[bf="${slot.slotId}"]')`);
@@ -14593,49 +14678,49 @@ function stringifyReactiveEffects(lines, plan, opts) {
       for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.wrappedExpression, attr.meta)) {
         lines.push(`${indent}    ${stmt}`);
       }
-      lines.push(`${indent}  })`);
+      lines.push(`${indent}  }${bindingBfId(slot.slotId)})`);
     }
     lines.push(`${indent}} }`);
   }
   for (const text of plan.outerTexts) {
-    emitOuterText(lines, indent, elVar, text);
+    emitOuterText(lines, indent, elVar, text, bindingBfId(text.slotId));
   }
   for (const cond of plan.conditionals) {
-    emitOuterConditional(lines, indent, elVar, cond);
+    emitOuterConditional(lines, indent, elVar, cond, pc);
   }
 }
-function emitOuterText(lines, indent, elVar, text) {
+function emitOuterText(lines, indent, elVar, text, bfId = "") {
   const varName = `__rt_${varSlotId(text.slotId)}`;
   lines.push(`${indent}{ const [${varName}] = $t(${elVar}, '${text.slotId}')`);
-  lines.push(`${indent}if (${varName}) createEffect(() => { ${varName}.textContent = String(${text.wrappedExpression}) }) }`);
+  lines.push(`${indent}if (${varName}) createEffect(() => { ${varName}.textContent = String(${text.wrappedExpression}) }${bfId}) }`);
 }
-function emitOuterConditional(lines, indent, elVar, cond) {
+function emitOuterConditional(lines, indent, elVar, cond, pc) {
   const armIndent = `${indent}    `;
   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);
+  emitArmBody(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);
+  emitArmBody(lines, cond.whenFalseArm, armIndent, pc);
   lines.push(`${indent}  }`);
-  lines.push(`${indent}})`);
+  lines.push(`${indent}}${profileBindingId(pc, cond.slotId)})`);
 }
-function emitArmBody(lines, arm, armIndent) {
+function emitArmBody(lines, arm, armIndent, pc) {
   stringifyBranchEventBindings(lines, arm.events, armIndent);
   stringifyBranchChildComponentInits(lines, arm.childComponents, armIndent);
-  stringifyBranchInnerLoops(lines, arm.innerLoops, armIndent);
-  stringifyLoopChildConditionals(lines, arm.nestedConditionals, armIndent);
+  stringifyBranchInnerLoops(lines, arm.innerLoops, armIndent, pc);
+  stringifyLoopChildConditionals(lines, arm.nestedConditionals, armIndent, pc);
   for (const text of arm.texts) {
-    emitArmText(lines, armIndent, text);
+    emitArmText(lines, armIndent, text, pc);
   }
 }
-function emitArmText(lines, indent, text) {
+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}) }) }`);
+  lines.push(`${indent}if (${varName}) createEffect(() => { ${varName}.textContent = String(${text.wrappedExpression}) }${profileBindingId(pc, text.slotId)}) }`);
 }
 
 // src/ir-to-client-js/control-flow/stringify/component-loop.ts
@@ -14652,8 +14737,10 @@ function stringifyComponentLoop(lines, plan) {
     componentPropsExpr,
     keyExpr,
     nestedComps,
-    childConditionalEffects
+    childConditionalEffects,
+    profileLoopId
   } = plan;
+  const loopBfId = profileLoopId ? `, ${JSON.stringify(profileLoopId)}` : "";
   lines.push(`  mapArray(() => ${arrayExpr}, ${containerVar}, ${keyFn}, (${paramHead}, ${indexParam}, __existing) => {`);
   if (paramUnwrap)
     lines.push(`    ${paramUnwrap}`);
@@ -14661,7 +14748,7 @@ function stringifyComponentLoop(lines, plan) {
   if (nestedComps.length === 0) {
     lines.push(`    if (__existing) { initChild('${scopedComp}', __existing, ${componentPropsExpr}); return __existing }`);
     lines.push(`    return createComponent('${scopedComp}', ${componentPropsExpr}, ${keyExpr})`);
-    lines.push(`  }, '${markerId}')`);
+    lines.push(`  }, '${markerId}'${loopBfId})`);
     return;
   }
   lines.push(`    if (__existing) {`);
@@ -14680,7 +14767,7 @@ function stringifyComponentLoop(lines, plan) {
     stringifyReactiveEffects(lines, childConditionalEffects, { indent: "    ", elVar: "__csrEl" });
   }
   lines.push(`    return __csrEl`);
-  lines.push(`  }, '${markerId}')`);
+  lines.push(`  }, '${markerId}'${loopBfId})`);
 }
 function emitNestedInit(lines, indent, parentVar, nc) {
   const scopedNc = nameForRegistryRef(nc.componentName);
@@ -14749,11 +14836,12 @@ function stringifyPlainLoop(lines, plan, topIndent = "  ") {
     stringifyAnchoredLoop(lines, plan, topIndent, anchorKeyExpr);
     return;
   }
+  const loopBfId = plan.profileLoopId ? `, ${JSON.stringify(plan.profileLoopId)}` : "";
   if (reactiveEffects === null && !bodyIsMultiRoot && childRefs.length === 0) {
     const unwrapInline = paramUnwrap ? `${paramUnwrap} ` : "";
     const preamble = mapPreambleWrapped ? `${mapPreambleWrapped}; ` : "";
     const cloneExpr = emitTemplateCloneInline(template);
-    lines.push(`${topIndent}mapArray(() => ${arrayExpr}, ${containerVar}, ${keyFn}, (${paramHead}, ${indexParam}, __existing) => { ${unwrapInline}${preamble}if (__existing) return __existing; ${cloneExpr} }, '${markerId}')`);
+    lines.push(`${topIndent}mapArray(() => ${arrayExpr}, ${containerVar}, ${keyFn}, (${paramHead}, ${indexParam}, __existing) => { ${unwrapInline}${preamble}if (__existing) return __existing; ${cloneExpr} }, '${markerId}'${loopBfId})`);
     return;
   }
   lines.push(`${topIndent}mapArray(() => ${arrayExpr}, ${containerVar}, ${keyFn}, (${paramHead}, ${indexParam}, __existing) => {`);
@@ -14773,7 +14861,7 @@ function stringifyPlainLoop(lines, plan, topIndent = "  ") {
   }
   emitLoopChildRefs(lines, childRefs, { indent: bodyIndent, elVar: "__el", bodyIsMultiRoot });
   lines.push(`${bodyIndent}return __el`);
-  lines.push(`${topIndent}}, '${markerId}')`);
+  lines.push(`${topIndent}}, '${markerId}'${loopBfId})`);
 }
 function stringifyAnchoredLoop(lines, plan, topIndent, anchorKeyExpr) {
   const {
@@ -14808,10 +14896,11 @@ function stringifyAnchoredLoop(lines, plan, topIndent, anchorKeyExpr) {
     stringifyReactiveEffects(lines, reactiveEffects, { indent: bodyIndent, elVar: "__anchor", bodyIsMultiRoot: false });
   }
   lines.push(`${bodyIndent}return __frag ?? __anchor`);
-  lines.push(`${topIndent}}, '${markerId}')`);
+  const loopBfId = plan.profileLoopId ? `, ${JSON.stringify(plan.profileLoopId)}` : "";
+  lines.push(`${topIndent}}, '${markerId}'${loopBfId})`);
 }
 function stringifyStaticLoop(lines, plan) {
-  const { containerVar, arrayExpr, param, indexParam, childIndexExpr, attrsBySlot, texts, childRefs, csrMaterialize } = plan;
+  const { containerVar, arrayExpr, param, indexParam, childIndexExpr, attrsBySlot, texts, childRefs, csrMaterialize, profileComponentName: pc } = plan;
   const hasAttrs = attrsBySlot.length > 0;
   const hasTexts = texts.length > 0;
   const hasRefs = childRefs.length > 0;
@@ -14873,14 +14962,14 @@ function stringifyStaticLoop(lines, plan) {
       for (const stmt of emitAttrUpdate(varName, attr.attrName, attr.expression, attr)) {
         lines.push(`            ${stmt}`);
       }
-      lines.push(`          })`);
+      lines.push(`          }${profileBindingId(pc, slotId)})`);
     }
     lines.push(`        }`);
   }
   for (const text of texts) {
     const vn = `__rt_${varSlotId(text.slotId)}`;
     lines.push(`        { const [${vn}] = $t(__iterEl, '${text.slotId}')`);
-    lines.push(`        if (${vn}) createEffect(() => { ${vn}.textContent = String(${text.expression}) }) }`);
+    lines.push(`        if (${vn}) createEffect(() => { ${vn}.textContent = String(${text.expression}) }${profileBindingId(pc, text.slotId)}) }`);
   }
   emitLoopChildRefs(lines, childRefs, { indent: "        ", elVar: "__iterEl", bodyIsMultiRoot: false });
   lines.push(`      }`);
@@ -14890,16 +14979,16 @@ function stringifyStaticLoop(lines, plan) {
 }
 
 // src/ir-to-client-js/control-flow/stringify/inner-loop.ts
-function stringifyInnerLoops(lines, plan, indent) {
+function stringifyInnerLoops(lines, plan, indent, pc) {
   for (const inner of plan) {
     if (inner.emit.mode === "reactive") {
-      emitReactive(lines, inner, indent);
+      emitReactive(lines, inner, indent, pc);
     } else {
-      emitStatic(lines, inner, indent);
+      emitStatic(lines, inner, indent, pc);
     }
   }
 }
-function emitReactive(lines, inner, indent) {
+function emitReactive(lines, inner, indent, pc) {
   const uid = inner.uidSuffix;
   const emit = inner.emit;
   if (emit.mode !== "reactive")
@@ -14930,14 +15019,15 @@ function emitReactive(lines, inner, indent) {
     emitComponentAndEventSetup(lines, `${indent}  `, `__innerEl${uid}`, [...emit.components], [...emit.events], inner.outerLoopParam, inner.outerLoopParamBindings);
   }
   if (inner.childLevels.length > 0) {
-    stringifyInnerLoops(lines, inner.childLevels, `${indent}  `);
+    stringifyInnerLoops(lines, inner.childLevels, `${indent}  `, pc);
   }
   for (const text of emit.reactiveTexts) {
+    const bf = profileBindingId(pc, text.slotId);
     if (text.insideConditional) {
-      lines.push(`${indent}  createEffect(() => { const [__rt] = $t(__innerEl${uid}, '${text.slotId}'); if (__rt) __rt.textContent = String(${text.wrappedExpression}) })`);
+      lines.push(`${indent}  createEffect(() => { const [__rt] = $t(__innerEl${uid}, '${text.slotId}'); if (__rt) __rt.textContent = String(${text.wrappedExpression}) }${bf})`);
     } else {
       lines.push(`${indent}  { const [__rt] = $t(__innerEl${uid}, '${text.slotId}')`);
-      lines.push(`${indent}  if (__rt) createEffect(() => { __rt.textContent = String(${text.wrappedExpression}) }) }`);
+      lines.push(`${indent}  if (__rt) createEffect(() => { __rt.textContent = String(${text.wrappedExpression}) }${bf}) }`);
     }
   }
   for (const attr of emit.reactiveAttrs) {
@@ -14947,7 +15037,7 @@ function emitReactive(lines, inner, indent) {
     for (const stmt of emitAttrUpdate(targetVar, attr.attrName, attr.wrappedExpression, attr.meta)) {
       lines.push(`${indent}    ${stmt}`);
     }
-    lines.push(`${indent}  }) }`);
+    lines.push(`${indent}  }${profileBindingId(pc, attr.slotId)}) }`);
   }
   emitLoopChildRefs(lines, emit.childRefs, {
     indent: `${indent}  `,
@@ -14955,9 +15045,9 @@ function emitReactive(lines, inner, indent) {
     bodyIsMultiRoot: emit.bodyIsMultiRoot
   });
   lines.push(`${indent}  return __innerEl${uid}`);
-  lines.push(`${indent}}, '${inner.markerId}') }`);
+  lines.push(`${indent}}, '${inner.markerId}'${profileBindingId(pc, inner.slotId)}) }`);
 }
-function emitStatic(lines, inner, indent) {
+function emitStatic(lines, inner, indent, pc) {
   const uid = inner.uidSuffix;
   const emit = inner.emit;
   if (emit.mode !== "static")
@@ -14975,7 +15065,7 @@ function emitStatic(lines, inner, indent) {
   }
   emitComponentAndEventSetup(lines, `${indent}  `, `__innerEl${uid}`, [...emit.components], [...emit.events], inner.outerLoopParam, inner.outerLoopParamBindings);
   if (inner.childLevels.length > 0) {
-    stringifyInnerLoops(lines, inner.childLevels, `${indent}  `);
+    stringifyInnerLoops(lines, inner.childLevels, `${indent}  `, pc);
   }
   emitLoopChildRefs(lines, emit.childRefs, {
     indent: `${indent}  `,
@@ -15007,7 +15097,9 @@ function stringifyCompositeLoop(lines, plan) {
     branchClearChildren,
     topIndent,
     bodyIndent: rawBodyIndent,
-    bodyIsMultiRoot
+    bodyIsMultiRoot,
+    profileComponentName: pc,
+    profileLoopId
   } = plan;
   const bodyIndent = branchClearChildren ? rawBodyIndent + "  " : rawBodyIndent;
   const mapArrayIndent = branchClearChildren ? topIndent + "  " : topIndent;
@@ -15033,18 +15125,19 @@ function stringifyCompositeLoop(lines, plan) {
   });
   emitComponentAndEventSetup(lines, bodyIndent, "__el", compsArr, eventsArr, loopParam, loopParamBindings, bodyIsMultiRoot);
   if (innerLoops.length > 0) {
-    stringifyInnerLoops(lines, innerLoops, bodyIndent);
+    stringifyInnerLoops(lines, innerLoops, bodyIndent, pc);
   }
   if (reactiveEffects) {
     stringifyReactiveEffects(lines, reactiveEffects, { indent: bodyIndent, elVar: "__el", bodyIsMultiRoot });
   }
   emitLoopChildRefs(lines, childRefs, { indent: bodyIndent, elVar: "__el", bodyIsMultiRoot });
   lines.push(`${bodyIndent}return __el`);
+  const loopBfId = profileLoopId ? `, ${JSON.stringify(profileLoopId)}` : "";
   if (branchClearChildren) {
-    lines.push(`${mapArrayIndent}}, '${markerId}')`);
+    lines.push(`${mapArrayIndent}}, '${markerId}'${loopBfId})`);
     lines.push(`${topIndent}}))`);
   } else {
-    lines.push(`${topIndent}}, '${markerId}')`);
+    lines.push(`${topIndent}}, '${markerId}'${loopBfId})`);
   }
 }
 
@@ -15059,8 +15152,14 @@ var NON_BUBBLING_EVENTS = new Set([
   "pointerenter",
   "pointerleave"
 ]);
+function withTurn(call, componentName, childSlotId, eventName) {
+  if (!componentName)
+    return call;
+  const id = JSON.stringify(`${componentName}#handler:${childSlotId}:${eventName}`);
+  return `beginTurn(${id}); try { ${call} } finally { endTurn() }`;
+}
 function stringifyEventDelegation(lines, plan) {
-  const { containerVar, events, itemLookup } = plan;
+  const { containerVar, events, itemLookup, profileComponentName } = plan;
   const eventsByName = new Map;
   for (const ev of events) {
     if (!eventsByName.has(ev.eventName))
@@ -15080,7 +15179,7 @@ function stringifyEventDelegation(lines, plan) {
       const childVar = varSlotId(ev.childSlotId);
       lines.push(`    const ${childVar}El = target.closest('[bf="${ev.childSlotId}"]')`);
       lines.push(`    if (${childVar}El) {`);
-      const handlerCall = `(${ev.handler.trim()})(__bfEvt)`;
+      const handlerCall = withTurn(`(${ev.handler.trim()})(__bfEvt)`, profileComponentName, ev.childSlotId, ev.eventName);
       switch (itemLookup.kind) {
         case "keyed":
           emitKeyedLookup(lines, ev, handlerCall, itemLookup);
@@ -15215,16 +15314,18 @@ function emitPlain(lines, plan) {
     reactiveEffects,
     eventDelegation,
     childRefs,
-    bodyIsMultiRoot
+    bodyIsMultiRoot,
+    profileLoopId
   } = plan;
+  const loopBfId = profileLoopId ? `, ${JSON.stringify(profileLoopId)}` : "";
   const unwrapInline = paramUnwrap ? `${paramUnwrap} ` : "";
   lines.push(`      __disposers.push(createDisposableEffect(() => {`);
   if (reactiveEffects === null && !bodyIsMultiRoot && childRefs.length === 0) {
     const cloneExpr = emitTemplateCloneInline(template);
     if (mapPreambleWrapped) {
-      lines.push(`        if (${containerVar}) mapArray(() => ${arrayExpr}, ${containerVar}, ${keyFn}, (${paramHead}, ${indexParam}, __existing) => { ${unwrapInline}if (__existing) return __existing; ${mapPreambleWrapped}; ${cloneExpr} }, '${markerId}')`);
+      lines.push(`        if (${containerVar}) mapArray(() => ${arrayExpr}, ${containerVar}, ${keyFn}, (${paramHead}, ${indexParam}, __existing) => { ${unwrapInline}if (__existing) return __existing; ${mapPreambleWrapped}; ${cloneExpr} }, '${markerId}'${loopBfId})`);
     } else {
-      lines.push(`        if (${containerVar}) mapArray(() => ${arrayExpr}, ${containerVar}, ${keyFn}, (${paramHead}, ${indexParam}, __existing) => { ${unwrapInline}if (__existing) return __existing; ${cloneExpr} }, '${markerId}')`);
+      lines.push(`        if (${containerVar}) mapArray(() => ${arrayExpr}, ${containerVar}, ${keyFn}, (${paramHead}, ${indexParam}, __existing) => { ${unwrapInline}if (__existing) return __existing; ${cloneExpr} }, '${markerId}'${loopBfId})`);
     }
   } else {
     lines.push(`        if (${containerVar}) mapArray(() => ${arrayExpr}, ${containerVar}, ${keyFn}, (${paramHead}, ${indexParam}, __existing) => {`);
@@ -15245,7 +15346,7 @@ function emitPlain(lines, plan) {
     }
     emitLoopChildRefs(lines, childRefs, { indent: "          ", elVar: "__el", bodyIsMultiRoot });
     lines.push(`          return __el`);
-    lines.push(`        }, '${markerId}')`);
+    lines.push(`        }, '${markerId}'${loopBfId})`);
   }
   lines.push(`      }))`);
   stringifyEventDelegation(lines, eventDelegation);
@@ -15256,19 +15357,21 @@ function stringifyInsert(lines, plan, opts) {
   const { leadingIndent, bodyIndent } = opts;
   const scopeVar = scopeRefToVar(plan.scope);
   const armIndent = leadingIndent + "  ";
+  const condBfId = plan.profileComponentName ? `, ${JSON.stringify(`${plan.profileComponentName}#binding:${plan.slotId}`)}` : "";
   lines.push(`${leadingIndent}insert(${scopeVar}, '${plan.slotId}', () => ${plan.condition}, {`);
-  emitArm(lines, plan.arms[0], plan.eventNameMode, armIndent, bodyIndent);
+  emitArm(lines, plan.arms[0], plan.eventNameMode, armIndent, bodyIndent, plan.profileComponentName);
   lines.push(`${leadingIndent}}, {`);
-  emitArm(lines, plan.arms[1], plan.eventNameMode, armIndent, bodyIndent);
-  lines.push(`${leadingIndent}})`);
+  emitArm(lines, plan.arms[1], plan.eventNameMode, armIndent, bodyIndent, plan.profileComponentName);
+  lines.push(`${leadingIndent}}${condBfId})`);
 }
-function emitArm(lines, arm, mode, armIndent, bodyIndent) {
+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);
+  emitArmBody2(lines, arm.body, mode, bodyIndent, profileComponentName);
   lines.push(`${armIndent}}`);
 }
-function emitArmBody2(lines, body, mode, indent) {
+function emitArmBody2(lines, body, mode, indent, profileComponentName) {
+  const bindingBfId = (slotId) => profileComponentName ? `, ${JSON.stringify(`${profileComponentName}#binding:${slotId}`)}` : "";
   const allSlotIds = new Set;
   for (const ev of body.events)
     allSlotIds.add(ev.slotId);
@@ -15289,7 +15392,7 @@ function emitArmBody2(lines, body, mode, indent) {
   for (const [slotId, slotEvents] of eventsBySlot) {
     const v = varSlotId(slotId);
     for (const ev of slotEvents) {
-      emitListenerLine(lines, indent, `_${v}`, ev.eventName, ev.handler, mode);
+      emitListenerLine(lines, indent, `_${v}`, ev.eventName, ev.handler, mode, ev.turnId);
     }
   }
   for (const ref of body.refs) {
@@ -15323,7 +15426,7 @@ function emitArmBody2(lines, body, mode, indent) {
       for (const stmt of emitAttrUpdate(elVar, attr.attrName, attr.expression, attr)) {
         lines.push(`${indent}    ${stmt}`);
       }
-      lines.push(`${indent}  }))`);
+      lines.push(`${indent}  }${bindingBfId(slotId)}))`);
     }
     lines.push(`${indent}} }`);
   }
@@ -15333,7 +15436,7 @@ function emitArmBody2(lines, body, mode, indent) {
     lines.push(`${indent}__disposers.push(createDisposableEffect(() => {`);
     lines.push(`${indent}  const __val = ${te.expression}`);
     lines.push(`${indent}  __anchor_${v} = __bfText(__anchor_${v}, __val)`);
-    lines.push(`${indent}}))`);
+    lines.push(`${indent}}${bindingBfId(te.slotId)}))`);
   }
   if (body.loops.length > 0) {
     stringifyBranchLoops(lines, body.loops);
@@ -15360,7 +15463,7 @@ function scopeRefToVar(ref) {
 }
 
 // src/ir-to-client-js/control-flow/plan/build-component-loop.ts
-function buildComponentLoopPlan(elem) {
+function buildComponentLoopPlan(elem, profileComponentName) {
   const { name } = elem.childComponent;
   const propsExpr = buildComponentPropsExpr2(elem.childComponent, elem.param);
   const keyExpr = wrapLoopParamAsAccessor(elem.key || "__idx", elem.param, elem.paramBindings);
@@ -15393,12 +15496,14 @@ function buildComponentLoopPlan(elem) {
     keyExpr,
     nestedComps,
     childRefs: buildChildRefBindings(elem.bindings.refs, elem.param, elem.paramBindings),
+    profileLoopId: profileComponentName ? `${profileComponentName}#binding:${elem.slotId}` : undefined,
     childConditionalEffects: hasChildConds ? buildReactiveEffectsPlan({
       attrs: [],
       texts: [],
       conditionals: elem.bindings.conditionals,
       loopParam: elem.param,
-      loopParamBindings: elem.paramBindings
+      loopParamBindings: elem.paramBindings,
+      profileComponentName
     }) : null
   };
 }
@@ -15406,21 +15511,21 @@ function buildComponentLoopPlan(elem) {
 // src/ir-to-client-js/control-flow/plan/build-loop.ts
 function buildLoopPlan(elem, opts) {
   if (elem.bodyIsItemConditional) {
-    return buildPlainLoopPlan(elem);
+    return buildPlainLoopPlan(elem, opts.profileComponentName);
   }
   if (elem.isStaticArray) {
-    return buildStaticLoopPlan(elem, opts.unsafeLocalNames);
+    return buildStaticLoopPlan(elem, opts.unsafeLocalNames, opts.profileComponentName);
   }
   const hasInnerStructure = (elem.nestedComponents?.length ?? 0) > 0 || (elem.innerLoops?.length ?? 0) > 0;
   if (elem.useElementReconciliation && hasInnerStructure) {
-    return buildTopLevelCompositePlan(elem);
+    return buildTopLevelCompositePlan(elem, opts.profileComponentName);
   }
   if (elem.childComponent) {
-    return buildComponentLoopPlan(elem);
+    return buildComponentLoopPlan(elem, opts.profileComponentName);
   }
-  return buildPlainLoopPlan(elem);
+  return buildPlainLoopPlan(elem, opts.profileComponentName);
 }
-function buildPlainLoopPlan(elem) {
+function buildPlainLoopPlan(elem, profileComponentName) {
   const wrap = (expr) => wrapLoopParamAsAccessor(expr, elem.param, elem.paramBindings);
   const { head: paramHead, unwrap: paramUnwrap } = destructureLoopParam(elem.param, elem.paramBindings);
   const hasReactive2 = elem.bindings.reactiveAttrs.length > 0 || elem.bindings.reactiveTexts.length > 0 || elem.bindings.conditionals.length > 0;
@@ -15428,6 +15533,7 @@ function buildPlainLoopPlan(elem) {
     kind: "plain",
     containerVar: `_${varSlotId(elem.slotId)}`,
     markerId: elem.markerId,
+    profileLoopId: profileComponentName ? `${profileComponentName}#binding:${elem.slotId}` : undefined,
     arrayExpr: buildChainedArrayExpr(elem),
     keyFn: loopKeyFn(elem),
     paramHead,
@@ -15435,14 +15541,14 @@ function buildPlainLoopPlan(elem) {
     indexParam: elem.index || "__idx",
     mapPreambleWrapped: elem.mapPreamble ? wrap(elem.mapPreamble) : "",
     template: elem.template,
-    reactiveEffects: hasReactive2 ? buildLoopReactiveEffectsPlan(elem) : null,
+    reactiveEffects: hasReactive2 ? buildLoopReactiveEffectsPlan(elem, profileComponentName) : null,
     childRefs: buildChildRefBindings(elem.bindings.refs, elem.param, elem.paramBindings),
     bodyIsMultiRoot: elem.bodyIsMultiRoot ?? false,
     anchored: elem.bodyIsItemConditional ?? false,
     anchorKeyExpr: elem.key ? wrap(elem.key) : elem.index || "__idx"
   };
 }
-function buildStaticLoopPlan(elem, unsafeLocalNames) {
+function buildStaticLoopPlan(elem, unsafeLocalNames, profileComponentName) {
   const attrsBySlotMap = new Map;
   if (!elem.childComponent) {
     for (const attr of elem.bindings.reactiveAttrs) {
@@ -15463,6 +15569,7 @@ function buildStaticLoopPlan(elem, unsafeLocalNames) {
     param: elem.param,
     indexParam,
     childIndexExpr,
+    profileComponentName,
     attrsBySlot: [...attrsBySlotMap].map(([slotId, attrs]) => [slotId, attrs]),
     texts: elem.bindings.reactiveTexts,
     childRefs: buildStaticChildRefBindings(elem.bindings.refs),
@@ -15485,15 +15592,17 @@ function buildStaticLoopMaterialize(elem, unsafeLocalNames) {
 
 // src/ir-to-client-js/control-flow.ts
 function emitConditionalUpdates(lines, ctx) {
+  const profileComponentName = ctx.profile ? ctx.componentName : undefined;
   for (const elem of ctx.conditionalElements) {
-    const plan = buildInsertPlan(elem, { scope: { kind: "top" }, eventNameMode: "dom" });
+    const plan = buildInsertPlan(elem, { scope: { kind: "top" }, eventNameMode: "dom", profileComponentName });
     stringifyInsert(lines, plan, { leadingIndent: "  ", bodyIndent: "      " });
     lines.push("");
   }
 }
 function emitClientOnlyConditionals(lines, ctx) {
+  const profileComponentName = ctx.profile ? ctx.componentName : undefined;
   for (const elem of ctx.clientOnlyConditionals) {
-    const plan = buildInsertPlan(elem, { scope: { kind: "top" }, eventNameMode: "raw" });
+    const plan = buildInsertPlan(elem, { scope: { kind: "top" }, eventNameMode: "raw", profileComponentName });
     lines.push(`  // @client conditional: ${elem.slotId}`);
     stringifyInsert(lines, plan, { leadingIndent: "  ", bodyIndent: "      " });
     lines.push("");
@@ -15501,20 +15610,23 @@ function emitClientOnlyConditionals(lines, ctx) {
 }
 function emitLoopUpdates(lines, ctx, unsafeLocalNames) {
   for (const elem of ctx.loopElements) {
-    const plan = buildLoopPlan(elem, { unsafeLocalNames });
+    const plan = buildLoopPlan(elem, {
+      unsafeLocalNames,
+      profileComponentName: ctx.profile ? ctx.componentName : undefined
+    });
     stringifyLoop(lines, plan);
-    emitLoopEventDelegation(lines, elem, plan.kind);
+    emitLoopEventDelegation(lines, elem, plan.kind, ctx.profile ? ctx.componentName : undefined);
   }
 }
-function emitLoopEventDelegation(lines, elem, kind) {
+function emitLoopEventDelegation(lines, elem, kind, profileComponentName) {
   if (kind === "static") {
     if (!elem.childComponent && elem.bindings.events.length > 0) {
-      stringifyEventDelegation(lines, buildStaticArrayDelegationPlan(elem));
+      stringifyEventDelegation(lines, buildStaticArrayDelegationPlan(elem, profileComponentName));
     }
     return;
   }
   if (kind === "plain" && !elem.useElementReconciliation && elem.bindings.events.length > 0) {
-    stringifyEventDelegation(lines, buildDynamicLoopDelegationPlan(elem));
+    stringifyEventDelegation(lines, buildDynamicLoopDelegationPlan(elem, profileComponentName));
   }
 }
 
@@ -15973,11 +16085,11 @@ function mapEventHandlers(lines, node, gen) {
 }
 
 // src/ir-to-client-js/index.ts
-function generateClientJs(ir, siblingComponents, localImportPrefixes, scope, adapterCapabilities) {
-  return generateClientJsWithSourceMap(ir, siblingComponents, localImportPrefixes, undefined, scope, adapterCapabilities).code;
+function generateClientJs(ir, siblingComponents, localImportPrefixes, scope, adapterCapabilities, profile) {
+  return generateClientJsWithSourceMap(ir, siblingComponents, localImportPrefixes, undefined, scope, adapterCapabilities, profile).code;
 }
-function generateClientJsWithSourceMap(ir, siblingComponents, localImportPrefixes, options, scope, adapterCapabilities) {
-  const ctx = createContext(ir, scope, adapterCapabilities);
+function generateClientJsWithSourceMap(ir, siblingComponents, localImportPrefixes, options, scope, adapterCapabilities, profile) {
+  const ctx = createContext(ir, scope, adapterCapabilities, profile);
   const siblingOffsets = computeLoopSiblingOffsets(ir.root);
   collectElements(ir.root, ctx, siblingOffsets);
   if (!needsClientJs(ctx)) {
@@ -16022,11 +16134,12 @@ function analyzeClientNeeds(ir) {
   }
   return { needsInit: true, usedProps: [...neededProps] };
 }
-function createContext(ir, scope, adapterCapabilities) {
+function createContext(ir, scope, adapterCapabilities, profile) {
   return {
     componentName: ir.metadata.componentName,
     fileScope: scope?.fileScope ?? "",
     nonExportedSiblings: scope?.nonExportedSiblings ?? new Set,
+    profile: profile ?? false,
     signals: ir.metadata.signals,
     memos: ir.metadata.memos,
     effects: ir.metadata.effects,
@@ -16775,8 +16888,41 @@ function extractSsrDefaults(metadata) {
     out[memo.name] = { value: resultToJsonable(value) };
     bindings[memo.name] = value;
   }
+  if (metadata.propsObjectName !== null) {
+    const referenced = new Set;
+    for (const sig of metadata.signals) {
+      if (!sig.getter || sig.isModule)
+        continue;
+      collectPropRefs(sig.initialValue, metadata.propsObjectName, referenced);
+    }
+    for (const memo of metadata.memos) {
+      if (memo.isModule)
+        continue;
+      collectPropRefs(memo.computation, metadata.propsObjectName, referenced);
+    }
+    for (const name of referenced) {
+      if (name in out)
+        continue;
+      out[name] = { propName: name, value: null };
+    }
+  }
   return Object.keys(out).length === 0 ? undefined : out;
 }
+function collectPropRefs(expr, propsObjectName, out) {
+  if (!expr || !expr.trim())
+    return;
+  const node = parseExpression2(expr);
+  if (!node)
+    return;
+  const visit3 = (n) => {
+    if (ts16.isPropertyAccessExpression(n) && ts16.isIdentifier(n.expression) && n.expression.text === propsObjectName && ts16.isIdentifier(n.name)) {
+      out.add(n.name.text);
+      return;
+    }
+    ts16.forEachChild(n, visit3);
+  };
+  visit3(node);
+}
 function resultToJsonable(v) {
   if (v === UNRESOLVED)
     return null;
@@ -17135,7 +17281,7 @@ function compileMultipleComponents(source, filePath, componentNames, options) {
         types,
         moduleExports: moduleExports || "",
         component,
-        clientJs: generateClientJs(componentIR, componentNames, options.localImportPrefixes, undefined, multiAdapterCaps) || undefined,
+        clientJs: generateClientJs(componentIR, componentNames, options.localImportPrefixes, undefined, multiAdapterCaps, options.profile) || undefined,
         adapterTypes: adapterOutput.types || undefined
       });
       errors.push(...componentIR.errors);
@@ -17488,7 +17634,7 @@ function compileJSX(source, filePath, options) {
       const result = generateClientJsWithSourceMap(componentIR, undefined, options.localImportPrefixes, {
         sourceMaps: true,
         generatedFileName: clientJsPath.split("/").pop()
-      }, undefined, adapterCaps);
+      }, undefined, adapterCaps, options.profile);
       errors.push(...componentIR.errors);
       if (result.code) {
         files.push({ path: clientJsPath, content: result.code, type: "clientJs" });
@@ -17497,7 +17643,7 @@ function compileJSX(source, filePath, options) {
         }
       }
     } else {
-      const clientJs = generateClientJs(componentIR, undefined, options.localImportPrefixes, undefined, adapterCaps);
+      const clientJs = generateClientJs(componentIR, undefined, options.localImportPrefixes, undefined, adapterCaps, options.profile);
       errors.push(...componentIR.errors);
       if (clientJs) {
         files.push({ path: clientJsPath, content: clientJs, type: "clientJs" });
@@ -17679,6 +17825,7 @@ class JsxAdapter extends BaseAdapter {
     return `${BF_COND}="${condId}"`;
   }
 }
+
 // src/adapters/template-imports.ts
 var CLIENT_PACKAGE_SOURCES = new Set([
   "@barefootjs/client",
@@ -17726,6 +17873,265 @@ function rewriteImportsForTemplate(imports, shimSource, rewriteRelative) {
 function specKey(s) {
   return `${s.isDefault ? "d" : ""}${s.isNamespace ? "n" : ""}:${s.name}:${s.alias ?? ""}`;
 }
+
+// src/adapters/test-adapter.ts
+class TestAdapter extends JsxAdapter {
+  name = "test";
+  extension = ".test.tsx";
+  jsxConfig = { preserveTypes: false };
+  generate(ir) {
+    this.componentName = ir.metadata.componentName;
+    const imports = this.generateImports(ir);
+    const types = this.generateTypes(ir);
+    const component = this.generateComponent(ir);
+    const defaultExport = ir.metadata.hasDefaultExport ? `
+export default ${this.componentName}` : "";
+    const sections = {
+      imports,
+      types: types || "",
+      component,
+      defaultExport
+    };
+    const template = [imports, types, component].filter(Boolean).join(`
+
+`) + defaultExport;
+    return {
+      template,
+      sections,
+      types: types || undefined,
+      extension: this.extension
+    };
+  }
+  generateImports(ir) {
+    const lines = [];
+    const templateImports = rewriteImportsForTemplate(ir.metadata.templateImports, undefined);
+    for (const imp of templateImports) {
+      if (imp.specifiers.length === 0) {
+        if (!imp.isTypeOnly) {
+          lines.push(`import '${imp.source}'`);
+        }
+        continue;
+      }
+      if (imp.isTypeOnly) {
+        lines.push(`import type ${this.formatImportSpecifiers(imp.specifiers)} from '${imp.source}'`);
+      } else {
+        lines.push(`import ${this.formatImportSpecifiers(imp.specifiers)} from '${imp.source}'`);
+      }
+    }
+    return lines.join(`
+`);
+  }
+  generateTypes(ir) {
+    const lines = [];
+    for (const typeDef of ir.metadata.typeDefinitions) {
+      lines.push(typeDef.definition);
+    }
+    const propsTypeName = ir.metadata.propsType?.raw;
+    if (propsTypeName && !ir.metadata.propsObjectName) {
+      lines.push("");
+      lines.push(`type ${this.componentName}PropsWithHydration = ${propsTypeName} & {`);
+      lines.push("  __instanceId?: string");
+      lines.push("  __bfScope?: string");
+      lines.push("}");
+    }
+    return lines.length > 0 ? lines.join(`
+`) : null;
+  }
+  generateComponent(ir) {
+    const name = ir.metadata.componentName;
+    const propsTypeName = ir.metadata.propsType?.raw;
+    const hasClientInteractivity = ir.metadata.signals.length > 0 || ir.metadata.memos.length > 0;
+    const typeAnnotation = propsTypeName ? `: ${name}PropsWithHydration` : ": { __instanceId?: string; __bfScope?: string }";
+    const jsxBody = this.renderNode(ir.root);
+    const signalInits = this.generateSignalInitializers(ir, jsxBody);
+    const scopeIdLine = hasClientInteractivity ? `(/_s\\d/.test(__bfScope || '') ? __bfScope : null) || __instanceId` : `__bfScope || __instanceId`;
+    const bodyRefText = [jsxBody, signalInits, scopeIdLine].join(`
+`);
+    const bfScopeAlias = /\b__bfScope\b/.test(bodyRefText) ? "__bfScope" : "__bfScope: _bfScope";
+    const propsParams = ir.metadata.propsParams.map((p) => p.defaultValue ? `${p.name} = ${p.defaultValue}` : p.name).join(", ");
+    const restPropsName = ir.metadata.restPropsName;
+    const hydrationProps = `__instanceId, ${bfScopeAlias}`;
+    const parts = [];
+    if (propsParams) {
+      parts.push(propsParams);
+    }
+    parts.push(hydrationProps);
+    if (restPropsName) {
+      parts.push(`...${restPropsName}`);
+    }
+    const fullPropsDestructure = `{ ${parts.join(", ")} }`;
+    const hasRequiredProps = ir.metadata.propsParams.some((p) => !p.optional && p.defaultValue === undefined && !p.isRest);
+    const propsTypeExpr = typeAnnotation.replace(/^:\s*/, "");
+    const noArgDefault = hasRequiredProps ? "" : ` = {} as ${propsTypeExpr}`;
+    const lines = [];
+    const exportPrefix = ir.metadata.isExported === false ? "" : "export ";
+    lines.push(`${exportPrefix}function ${name}(${fullPropsDestructure}${typeAnnotation}${noArgDefault}) {`);
+    if (hasClientInteractivity) {
+      lines.push(`  const __scopeId = (/_s\\d/.test(__bfScope || '') ? __bfScope : null) || __instanceId || \`${name}_\${Math.random().toString(36).slice(2, 8)}\``);
+    } else {
+      lines.push(`  const __scopeId = __bfScope || __instanceId || \`${name}_\${Math.random().toString(36).slice(2, 8)}\``);
+    }
+    if (signalInits) {
+      lines.push(signalInits);
+    }
+    lines.push("");
+    lines.push(`  return (`);
+    lines.push(`    ${jsxBody}`);
+    lines.push(`  )`);
+    lines.push(`}`);
+    return lines.join(`
+`);
+  }
+  renderNode(node) {
+    switch (node.type) {
+      case "element":
+        return this.renderElement(node);
+      case "text":
+        return node.value;
+      case "expression":
+        return this.renderExpression(node);
+      case "conditional":
+        return this.renderConditional(node);
+      case "loop":
+        return this.renderLoop(node);
+      case "component":
+        return this.renderComponent(node);
+      case "fragment":
+        return this.renderFragment(node);
+      case "slot":
+        return "{children}";
+      default:
+        return "";
+    }
+  }
+  renderElement(element) {
+    const tag = element.tag;
+    const attrs = this.renderAttributes(element);
+    const children = this.renderChildren(element.children);
+    let hydrationAttrs = "";
+    if (element.needsScope) {
+      hydrationAttrs += " bf-s={__scopeId}";
+    }
+    if (element.slotId) {
+      hydrationAttrs += ` bf="${element.slotId}"`;
+    }
+    if (children) {
+      return `<${tag}${attrs}${hydrationAttrs}>${children}</${tag}>`;
+    } else {
+      return `<${tag}${attrs}${hydrationAttrs} />`;
+    }
+  }
+  renderExpression(expr) {
+    if (expr.expr === "null" || expr.expr === "undefined") {
+      return "null";
+    }
+    if (expr.reactive && expr.slotId) {
+      return `{bfText("${expr.slotId}")}{${expr.expr}}{bfTextEnd()}`;
+    }
+    return `{${expr.expr}}`;
+  }
+  renderConditional(cond) {
+    const whenTrue = this.renderNodeRaw(cond.whenTrue);
+    let whenFalse = this.renderNodeRaw(cond.whenFalse);
+    if (!whenFalse || whenFalse === "" || whenFalse === "null") {
+      whenFalse = "null";
+    }
+    return `{${cond.condition} ? ${whenTrue} : ${whenFalse}}`;
+  }
+  renderLoop(loop) {
+    const indexParam = loop.index ? `, ${loop.index}` : "";
+    const children = this.renderChildren(loop.children);
+    const safeChildren = children.startsWith("{") ? `<>${children}</>` : children;
+    return `{${loop.array}.map((${loop.param}${indexParam}) => ${safeChildren})}`;
+  }
+  renderComponent(comp) {
+    const props = this.renderComponentProps(comp);
+    const children = this.renderChildren(comp.children);
+    const scopeAttr = " __bfScope={__scopeId}";
+    if (children) {
+      return `<${comp.name}${props}${scopeAttr}>${children}</${comp.name}>`;
+    } else {
+      return `<${comp.name}${props}${scopeAttr} />`;
+    }
+  }
+  renderFragment(fragment) {
+    const children = this.renderChildren(fragment.children);
+    return `<>${children}</>`;
+  }
+  renderAttributes(element) {
+    const parts = [];
+    for (const attr of element.attrs) {
+      const attrName = attr.name === "class" ? "className" : attr.name;
+      switch (attr.value.kind) {
+        case "spread":
+          parts.push(`{...${attr.value.expr}}`);
+          break;
+        case "boolean-attr":
+          parts.push(attrName);
+          break;
+        case "expression":
+          parts.push(`${attrName}={${attr.value.expr}}`);
+          break;
+        case "template":
+          parts.push(`${attrName}={${this.flattenTemplate(attr.value)}}`);
+          break;
+        case "literal":
+          parts.push(`${attrName}="${attr.value.value}"`);
+          break;
+        case "boolean-shorthand":
+        case "jsx-children":
+          break;
+      }
+    }
+    for (const event of element.events) {
+      const handlerName = event.originalAttr ?? `on${event.name.charAt(0).toUpperCase()}${event.name.slice(1)}`;
+      parts.push(`${handlerName}={() => {}}`);
+    }
+    return parts.length > 0 ? " " + parts.join(" ") : "";
+  }
+  flattenTemplate(value) {
+    const v = value;
+    return "`" + v.parts.map((p) => {
+      if (p.type === "string")
+        return p.value;
+      if (p.type === "ternary")
+        return `\${${p.condition} ? '${p.whenTrue}' : '${p.whenFalse}'}`;
+      return `\${(${JSON.stringify(p.cases)})[${p.key}]}`;
+    }).join("") + "`";
+  }
+  renderComponentProps(comp) {
+    const parts = [];
+    for (const prop of comp.props) {
+      switch (prop.value.kind) {
+        case "jsx-children": {
+          const rendered = prop.value.children.map((c) => this.renderNode(c)).join("");
+          parts.push(`${prop.name}={<>${rendered}</>}`);
+          break;
+        }
+        case "spread":
+          parts.push(`{...${prop.value.expr}}`);
+          break;
+        case "expression":
+          parts.push(`${prop.name}={${prop.value.expr}}`);
+          break;
+        case "template":
+          parts.push(`${prop.name}={${this.flattenTemplate(prop.value)}}`);
+          break;
+        case "boolean-shorthand":
+          parts.push(prop.name);
+          break;
+        case "literal":
+          parts.push(`${prop.name}="${prop.value.value}"`);
+          break;
+        case "boolean-attr":
+          parts.push(prop.name);
+          break;
+      }
+    }
+    return parts.length > 0 ? " " + parts.join(" ") : "";
+  }
+}
+var testAdapter = new TestAdapter;
 // src/adapters/parsed-expr-emitter.ts
 function emitParsedExpr(expr, emitter) {
   const emit = (child) => emitParsedExpr(child, emitter);
@@ -17930,7 +18336,139 @@ function parseAndMerge(content, importsBySource, otherImports, codeSections) {
     codeSections.push(code);
   }
 }
+// src/loop-destructure.ts
+var SIMPLE_FIELD = /^\.[A-Za-z_$][\w$]*$/;
+function isLowerableObjectRestDestructure(loop) {
+  const bindings = loop.paramBindings;
+  if (!bindings || bindings.length === 0)
+    return false;
+  if (loop.filterPredicate)
+    return false;
+  for (const name of [...bindings.map((b) => b.name), loop.index]) {
+    if (name && name.startsWith("__bf_"))
+      return false;
+  }
+  for (const b of bindings) {
+    if (b.rest) {
+      if (b.rest.kind !== "object")
+        return false;
+    } else if (!SIMPLE_FIELD.test(b.path)) {
+      return false;
+    }
+  }
+  const restNames = bindings.filter((b) => b.rest).map((b) => b.name);
+  if (restNames.length === 0)
+    return true;
+  return !restNamesMisused(loop, restNames);
+}
+function restNamesMisused(loop, names) {
+  const valueUse = names.map((n) => new RegExp(`(?<![\\w.$])${escapeRe(n)}(?!\\s*\\??\\.)(?![\\w$])`));
+  let misused = false;
+  const check = (s) => {
+    if (!s || misused)
+      return;
+    for (const re of valueUse) {
+      if (re.test(s)) {
+        misused = true;
+        return;
+      }
+    }
+  };
+  const attr = (v) => {
+    if (v.kind === "expression" || v.kind === "spread") {
+      check(v.expr);
+      check(v.templateExpr);
+    } else if (v.kind === "template") {
+      v.parts.forEach(part);
+    }
+  };
+  const part = (p) => {
+    if (p.type === "ternary") {
+      check(p.condition);
+      check(p.templateCondition);
+      check(p.whenTrue);
+      check(p.whenFalse);
+    } else if (p.type === "lookup") {
+      check(p.key);
+      check(p.templateKey);
+    }
+  };
+  const visitLoop = (l) => {
+    if (misused)
+      return;
+    check(l.array);
+    check(l.templateArray);
+    check(l.key);
+    check(l.mapPreamble);
+    check(l.templateMapPreamble);
+    if (l.flatMapCallback) {
+      check(l.flatMapCallback.body);
+      check(l.flatMapCallback.templateBody);
+      l.flatMapCallback.fragments.forEach((f) => visit3(f.ir));
+    }
+    l.children.forEach(visit3);
+  };
+  const visit3 = (node) => {
+    if (misused)
+      return;
+    switch (node.type) {
+      case "expression":
+        check(node.expr);
+        check(node.templateExpr);
+        break;
+      case "conditional":
+        check(node.condition);
+        check(node.templateCondition);
+        visit3(node.whenTrue);
+        visit3(node.whenFalse);
+        break;
+      case "if-statement":
+        check(node.condition);
+        check(node.templateCondition);
+        for (const sv of node.scopeVariables) {
+          check(sv.initializer);
+          check(sv.templateInitializer);
+        }
+        visit3(node.consequent);
+        if (node.alternate)
+          visit3(node.alternate);
+        break;
+      case "element":
+        node.attrs.forEach((a) => attr(a.value));
+        node.events.forEach((e) => check(e.handler));
+        node.children.forEach(visit3);
+        break;
+      case "component":
+        node.props.forEach((p) => attr(p.value));
+        node.children.forEach(visit3);
+        break;
+      case "provider":
+        attr(node.valueProp.value);
+        node.children.forEach(visit3);
+        break;
+      case "fragment":
+        node.children.forEach(visit3);
+        break;
+      case "async":
+        visit3(node.fallback);
+        node.children.forEach(visit3);
+        break;
+      case "loop":
+        visitLoop(node);
+        break;
+      case "text":
+      case "slot":
+        break;
+    }
+  };
+  visitLoop(loop);
+  return misused;
+}
+function escapeRe(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
 // src/debug.ts
+import ts19 from "typescript";
 function buildComponentGraph(source, filePath, componentName) {
   const ctx = analyzeComponent(source, filePath, componentName);
   if (!ctx.jsxReturn) {
@@ -17961,15 +18499,55 @@ function buildComponentGraph(source, filePath, componentName) {
     root: ir,
     errors: []
   };
-  return buildGraphFromIR(componentIR);
+  const graph = buildGraphFromIR(componentIR);
+  return graph.sourceFile ? graph : { ...graph, sourceFile: filePath };
 }
 function buildGraphFromIR(ir) {
   const meta = ir.metadata;
   const signalGetters = new Set(meta.signals.map((s) => s.getter));
   const memoNames = new Set(meta.memos.map((m) => m.name));
   const signalSetters = new Map(meta.signals.filter((s) => s.setter).map((s) => [s.setter, s.getter]));
+  const destructuredPropNames = new Set(meta.propsParams.map((p) => p.name).filter((n) => n !== "children"));
+  const propsObjectName = meta.propsObjectName;
+  const constByName = new Map(meta.localConstants.map((c) => [c.name, c]));
+  const propDerivedConsts = new Set;
+  {
+    const onStack = new Set;
+    const derivesFromProp = (name) => {
+      if (propDerivedConsts.has(name))
+        return true;
+      const c = constByName.get(name);
+      if (!c?.freeIdentifiers || onStack.has(name))
+        return false;
+      onStack.add(name);
+      let derived = false;
+      for (const free of c.freeIdentifiers) {
+        if (destructuredPropNames.has(free) || free === propsObjectName || derivesFromProp(free)) {
+          derived = true;
+          break;
+        }
+      }
+      onStack.delete(name);
+      if (derived)
+        propDerivedConsts.add(name);
+      return derived;
+    };
+    for (const c of meta.localConstants)
+      derivesFromProp(c.name);
+  }
+  const exprReadsProp = (expr, freeIds) => {
+    for (const name of destructuredPropNames) {
+      if (freeIds ? freeIds.has(name) : tokenContainsIdent(expr, name))
+        return true;
+    }
+    for (const name of propDerivedConsts) {
+      if (freeIds ? freeIds.has(name) : tokenContainsIdent(expr, name))
+        return true;
+    }
+    return propsObjectName ? exprReadsPropMember(expr, propsObjectName) : false;
+  };
   const domBindings = [];
-  collectDomBindings(ir.root, domBindings, signalGetters, memoNames);
+  collectDomBindings(ir.root, domBindings, signalGetters, memoNames, undefined, new Set, exprReadsProp);
   const signalConsumers = new Map;
   for (const s of meta.signals)
     signalConsumers.set(s.getter, []);
@@ -18040,8 +18618,8 @@ function buildGraphFromIR(ir) {
     domBindings
   };
 }
-function buildComponentAnalysis(source, filePath, componentName) {
-  const ctx = analyzeComponent(source, filePath, componentName);
+function buildComponentAnalysis(source, filePath, componentName, program) {
+  const ctx = analyzeComponent(source, filePath, componentName, program);
   const emptyIR = {
     version: "0.1",
     metadata: buildMetadata(ctx),
@@ -18058,8 +18636,8 @@ function buildComponentAnalysis(source, filePath, componentName) {
   const ir = { version: "0.1", metadata: buildMetadata(ctx), root, errors: [] };
   return { graph: buildGraphFromIR(ir), ir };
 }
-function buildEventSummary(source, filePath, componentName) {
-  const { graph, ir } = buildComponentAnalysis(source, filePath, componentName);
+function buildEventSummary(source, filePath, componentName, program) {
+  const { graph, ir } = buildComponentAnalysis(source, filePath, componentName, program);
   const setterToSignal = new Map;
   for (const s of ir.metadata.signals) {
     if (s.setter)
@@ -18892,8 +19470,8 @@ function formatFallbackExplanations(componentName, fallbacks) {
   return lines.join(`
 `);
 }
-function buildComponentSummary(source, filePath, componentName) {
-  const { graph, ir } = buildComponentAnalysis(source, filePath, componentName);
+function buildComponentSummary(source, filePath, componentName, program) {
+  const { graph, ir } = buildComponentAnalysis(source, filePath, componentName, program);
   const meta = ir.metadata;
   const clientNeeds = analyzeClientNeeds(ir);
   const hasReactiveState = meta.signals.length > 0 || meta.memos.length > 0 || meta.effects.length > 0;
@@ -18995,18 +19573,23 @@ function inferWrapReasonForAttrLike(hasStringReactive, hasPropsRef, flags) {
   const decision = decideWrapFromAstFlags(flags);
   return decision.wrap ? decision.reason : undefined;
 }
-function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag) {
+function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag, loopParams = new Set, readsProp = () => false) {
+  const exprReadsLoopParam = (n) => loopParams.size > 0 && (n.origin?.freeRefs?.some((r) => loopParams.has(r.name)) ?? false);
+  const attrReadsLoopParam = (free) => loopParams.size > 0 && free !== undefined && [...loopParams].some((p) => free.has(p));
   switch (node.type) {
     case "element": {
       for (const attr of node.attrs) {
         if (attr.value.kind !== "expression" && attr.value.kind !== "template" && attr.value.kind !== "spread")
           continue;
+        if (attr.name === "key" && loopParams.size > 0)
+          continue;
         const expr = attrValueToString2(attr.value);
         if (!expr)
           continue;
         const deps = extractReactiveDeps(expr, signalGetters, memoNames);
-        const isReactive = deps.length > 0;
-        const wrapReason = inferWrapReasonForAttrLike(isReactive, false, attr);
+        const isReactive = deps.length > 0 || attrReadsLoopParam(attr.freeIdentifiers);
+        const hasPropsRef = readsProp(expr, attr.freeIdentifiers);
+        const wrapReason = inferWrapReasonForAttrLike(isReactive, hasPropsRef, attr);
         if (wrapReason) {
           bindings.push({
             kind: "dom",
@@ -19014,7 +19597,7 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag)
             slotId: node.slotId ?? "?",
             deps,
             type: "attribute",
-            classification: isReactive ? "reactive" : "fallback",
+            classification: isReactive || hasPropsRef ? "reactive" : "fallback",
             expression: expr,
             wrapReason,
             loc: attr.loc,
@@ -19035,13 +19618,14 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag)
         });
       }
       for (const child of node.children) {
-        collectDomBindings(child, bindings, signalGetters, memoNames, node.tag);
+        collectDomBindings(child, bindings, signalGetters, memoNames, node.tag, loopParams, readsProp);
       }
       break;
     }
     case "expression": {
       const decision = decideWrapFromAstFlags(node);
-      if (decision.wrap && node.slotId) {
+      const loopReactive = exprReadsLoopParam(node);
+      if ((decision.wrap || loopReactive) && node.slotId) {
         const deps = extractReactiveDeps(node.expr, signalGetters, memoNames);
         const preview = parentTag ? `<${parentTag}>{${truncateExpr(node.expr)}}</${parentTag}>` : `{${truncateExpr(node.expr)}}`;
         bindings.push({
@@ -19050,9 +19634,9 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag)
           slotId: node.slotId,
           deps,
           type: "text",
-          classification: decision.reason === "proven-reactive" ? "reactive" : "fallback",
+          classification: decision.wrap && decision.reason === "proven-reactive" || loopReactive ? "reactive" : "fallback",
           expression: node.expr,
-          wrapReason: decision.reason,
+          wrapReason: decision.wrap ? decision.reason : "string-reactive",
           loc: node.loc,
           jsxPreview: preview
         });
@@ -19061,7 +19645,8 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag)
     }
     case "conditional": {
       const decision = decideWrapFromAstFlags(node);
-      if (decision.wrap && node.slotId) {
+      const loopReactive = loopParams.size > 0 && (node.origin?.freeRefs?.some((r) => loopParams.has(r.name)) ?? false);
+      if ((decision.wrap || loopReactive) && node.slotId) {
         const deps = extractReactiveDeps(node.condition, signalGetters, memoNames);
         bindings.push({
           kind: "dom",
@@ -19069,24 +19654,25 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag)
           slotId: node.slotId,
           deps,
           type: "conditional",
-          classification: decision.reason === "proven-reactive" ? "reactive" : "fallback",
+          classification: decision.wrap && decision.reason === "proven-reactive" || loopReactive ? "reactive" : "fallback",
           expression: node.condition,
-          wrapReason: decision.reason,
+          wrapReason: decision.wrap ? decision.reason : "string-reactive",
           loc: node.loc,
           jsxPreview: `{${truncateExpr(node.condition)} ? ... : ...}`
         });
       }
-      collectDomBindings(node.whenTrue, bindings, signalGetters, memoNames, parentTag);
-      collectDomBindings(node.whenFalse, bindings, signalGetters, memoNames, parentTag);
+      collectDomBindings(node.whenTrue, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
+      collectDomBindings(node.whenFalse, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
       break;
     }
     case "loop": {
       if (node.slotId) {
         const deps = extractReactiveDeps(node.array, signalGetters, memoNames);
-        const isReactive = deps.length > 0 || node.callsReactiveGetters === true;
+        const loopReactive = loopParams.size > 0 && node.arrayFreeIdentifiers !== undefined && [...loopParams].some((p) => node.arrayFreeIdentifiers.has(p));
+        const isReactive = deps.length > 0 || node.callsReactiveGetters === true || loopReactive;
         const isFallback = !isReactive && node.hasFunctionCalls === true;
         if (isReactive || isFallback) {
-          const wrapReason = deps.length > 0 ? "string-reactive" : node.callsReactiveGetters ? "proven-reactive" : "fallback-function-calls";
+          const wrapReason = deps.length > 0 || loopReactive ? "string-reactive" : node.callsReactiveGetters ? "proven-reactive" : "fallback-function-calls";
           bindings.push({
             kind: "dom",
             label: `loop "${node.slotId}"`,
@@ -19101,8 +19687,13 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag)
           });
         }
       }
+      const childLoopParams = new Set(loopParams);
+      for (const p of extractLoopParamNames(node.param, node))
+        childLoopParams.add(p);
+      if (node.index)
+        childLoopParams.add(node.index);
       for (const child of node.children) {
-        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag);
+        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag, childLoopParams, readsProp);
       }
       break;
     }
@@ -19116,7 +19707,7 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag)
         if (!propValue)
           continue;
         const deps = extractReactiveDeps(propValue, signalGetters, memoNames);
-        const hasPropsRef = propValue.includes("props.");
+        const hasPropsRef = readsProp(propValue, prop.freeIdentifiers);
         const isReactive = deps.length > 0 || hasPropsRef;
         const wrapReason = inferWrapReasonForAttrLike(deps.length > 0, hasPropsRef, prop);
         if (wrapReason) {
@@ -19135,21 +19726,21 @@ function collectDomBindings(node, bindings, signalGetters, memoNames, parentTag)
         }
       }
       for (const child of node.children) {
-        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag);
+        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
       }
       break;
     }
     case "fragment":
     case "provider": {
       for (const child of node.children) {
-        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag);
+        collectDomBindings(child, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
       }
       break;
     }
     case "if-statement": {
-      collectDomBindings(node.consequent, bindings, signalGetters, memoNames, parentTag);
+      collectDomBindings(node.consequent, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
       if (node.alternate) {
-        collectDomBindings(node.alternate, bindings, signalGetters, memoNames, parentTag);
+        collectDomBindings(node.alternate, bindings, signalGetters, memoNames, parentTag, loopParams, readsProp);
       }
       break;
     }
@@ -19159,6 +19750,26 @@ function truncateExpr(expr, max = 40) {
   const s = expr.replace(/\s+/g, " ").trim();
   return s.length > max ? s.slice(0, max - 1) + "…" : s;
 }
+function exprReadsPropMember(expr, propsObjectName) {
+  let sf;
+  try {
+    sf = ts19.createSourceFile("__attr.tsx", `(${expr})`, ts19.ScriptTarget.Latest, true, ts19.ScriptKind.TSX);
+  } catch {
+    return false;
+  }
+  let found = false;
+  const visit3 = (n) => {
+    if (found)
+      return;
+    if (ts19.isPropertyAccessExpression(n) && ts19.isIdentifier(n.expression) && n.expression.text === propsObjectName && n.name.text !== "children") {
+      found = true;
+      return;
+    }
+    ts19.forEachChild(n, visit3);
+  };
+  visit3(sf);
+  return found;
+}
 function attrValueToString2(value) {
   switch (value.kind) {
     case "literal":
@@ -19223,8 +19834,1068 @@ function findSourceFile2(meta) {
   }
   return null;
 }
+// src/profiler.ts
+import ts20 from "typescript";
+var DEFAULT_FANOUT_THRESHOLD = 8;
+function buildStaticBudget(source, filePath, componentName, options = {}) {
+  const threshold = options.fanOutThreshold ?? DEFAULT_FANOUT_THRESHOLD;
+  const program = createProgramForFile(source, filePath)?.program;
+  const { graph } = buildComponentAnalysis(source, filePath, componentName, program);
+  const summary = buildComponentSummary(source, filePath, componentName, program);
+  const subscriptions = graph.signals.reduce((n, s) => n + s.consumers.filter((c) => !isEventHandlerConsumer(c)).length, 0);
+  const fanOut = graph.signals.map((s) => {
+    const subscribers = transitiveSubscriberCount(graph, s.name);
+    return { signal: s.name, subscribers, hot: subscribers >= threshold, loc: s.loc };
+  }).sort((a, b) => b.subscribers - a.subscribers);
+  const { depth, chain } = longestMemoChain(graph);
+  const hasReactiveState = graph.signals.length > 0 || graph.memos.length > 0;
+  const observedInComponent = graph.signals.some((s) => transitiveSubscriberCount(graph, s.name) > 0) || graph.memos.some((m) => transitiveSubscriberCount(graph, m.name) > 0);
+  const crossComponentOnly = hasReactiveState && !observedInComponent;
+  return {
+    componentName: summary.componentName,
+    sourceFile: summary.sourceFile,
+    kind: "static-budget",
+    signals: graph.signals.length,
+    memos: graph.memos.length,
+    effects: graph.effects.length,
+    loops: summary.loops,
+    subscriptions,
+    memoChainDepth: depth,
+    memoChainLongest: chain,
+    fanOut,
+    crossComponentOnly
+  };
+}
+function isEventHandlerEntry(kind, name) {
+  return kind === "dom" && /^\w+ handler "/.test(name);
+}
+function isEventHandlerConsumer(consumer) {
+  const i = consumer.indexOf(":");
+  return i > 0 && isEventHandlerEntry(consumer.slice(0, i), consumer.slice(i + 1));
+}
+function transitiveSubscriberCount(graph, name) {
+  const path = traceUpdatePath(graph, name);
+  if (!path)
+    return 0;
+  const seen = new Set;
+  const walk = (entries) => {
+    for (const e of entries) {
+      if (!isEventHandlerEntry(e.kind, e.name))
+        seen.add(`${e.kind}:${e.name}`);
+      walk(e.children);
+    }
+  };
+  walk(path.dependents);
+  return seen.size;
+}
+function longestMemoChain(graph) {
+  const memoChainFrom = (entry) => {
+    if (entry.kind !== "memo")
+      return [];
+    let best2 = [];
+    for (const child of entry.children) {
+      const c = memoChainFrom(child);
+      if (c.length > best2.length)
+        best2 = c;
+    }
+    return [entry.name, ...best2];
+  };
+  let best = [];
+  for (const memo of graph.memos) {
+    const path = traceUpdatePath(graph, memo.name);
+    let downstream = [];
+    for (const dep of path?.dependents ?? []) {
+      const c = memoChainFrom(dep);
+      if (c.length > downstream.length)
+        downstream = c;
+    }
+    const chain = [memo.name, ...downstream];
+    if (chain.length > best.length)
+      best = chain;
+  }
+  return { depth: best.length, chain: best };
+}
+function formatStaticBudget(b) {
+  const lines = [];
+  lines.push(`${b.componentName} — static reactivity budget`);
+  lines.push(`  signals: ${b.signals}   memos: ${b.memos}   effects: ${b.effects}   loops: ${b.loops}`);
+  lines.push(`  subscriptions: ${b.subscriptions}`);
+  if (b.memoChainDepth > 0) {
+    lines.push(`  memo-chain depth: ${b.memoChainDepth}   (${b.memoChainLongest.join(" → ")})`);
+  }
+  const shown = b.fanOut.filter((f) => f.subscribers > 0).slice(0, 5);
+  if (shown.length > 0) {
+    lines.push("  fan-out (top):");
+    for (const f of shown) {
+      lines.push(`    ${f.signal.padEnd(12)} → ${f.subscribers} subscribers${f.hot ? "   ⚠ high" : ""}`);
+    }
+  }
+  if (b.crossComponentOnly) {
+    lines.push(`  ⓘ compound: ${b.signals} signal(s) / ${b.memos} memo(s) but 0 in-component subscriptions —`);
+    lines.push("    consumers are likely in composed child components (or it is read only from handlers);");
+    lines.push("    run with --scenario to measure across the composition boundary.");
+  }
+  lines.push("  note: run with --scenario to measure actual cost; static budget is predictive only.");
+  return lines.join(`
+`);
+}
+function diffStaticBudget(base, head) {
+  const baseFan = new Map(base.fanOut.map((f) => [f.signal, f.subscribers]));
+  const headFan = new Map(head.fanOut.map((f) => [f.signal, f.subscribers]));
+  const signals = new Set([...baseFan.keys(), ...headFan.keys()]);
+  const fanOut = [];
+  for (const sig of signals) {
+    const before = baseFan.get(sig) ?? 0;
+    const after = headFan.get(sig) ?? 0;
+    if (before !== after)
+      fanOut.push({ signal: sig, before, after });
+  }
+  fanOut.sort((a, b) => b.after - b.before - (a.after - a.before));
+  const d = {
+    kind: "diff",
+    componentName: head.componentName,
+    signals: head.signals - base.signals,
+    memos: head.memos - base.memos,
+    effects: head.effects - base.effects,
+    loops: head.loops - base.loops,
+    subscriptions: head.subscriptions - base.subscriptions,
+    memoChainDepth: head.memoChainDepth - base.memoChainDepth,
+    fanOut
+  };
+  const regressed = d.signals > 0 || d.memos > 0 || d.effects > 0 || d.subscriptions > 0 || d.memoChainDepth > 0 || fanOut.some((f) => f.after > f.before);
+  return { ...d, regressed };
+}
+function formatBudgetDiff(d) {
+  const lines = [];
+  lines.push(`${d.componentName} — reactivity diff`);
+  const metric = (label, v) => {
+    if (v !== 0)
+      lines.push(`  ${v > 0 ? "+" : ""}${v} ${label}`);
+  };
+  metric("signals", d.signals);
+  metric("memos", d.memos);
+  metric("effects", d.effects);
+  metric("loops", d.loops);
+  metric("subscriptions", d.subscriptions);
+  if (d.memoChainDepth !== 0) {
+    lines.push(`  memo chain ${d.memoChainDepth > 0 ? "deepened" : "shortened"} by ${Math.abs(d.memoChainDepth)}`);
+  }
+  for (const f of d.fanOut) {
+    lines.push(`  signal \`${f.signal}\` fan-out ${f.before}→${f.after}`);
+  }
+  if (lines.length === 1)
+    lines.push("  no structural reactivity change");
+  else
+    lines.push(d.regressed ? "  ⚠ reactivity regressed" : "  ✓ no regression");
+  return lines.join(`
+`);
+}
+function parseProfilerId(id) {
+  const hash = id.indexOf("#");
+  if (hash < 0)
+    return null;
+  const colon = id.indexOf(":", hash);
+  if (colon < 0)
+    return null;
+  const component = id.slice(0, hash);
+  const kind = id.slice(hash + 1, colon);
+  const rest = id.slice(colon + 1);
+  if (!component || !kind || !rest)
+    return null;
+  return { component, kind, rest };
+}
+function buildIdIndex(graph) {
+  const comp = graph.componentName;
+  const index = new Map;
+  for (const s of graph.signals) {
+    index.set(`${comp}#signal:${s.name}`, { kind: "signal", name: s.name, loc: s.loc });
+    if (s.setter) {
+      index.set(`${comp}#effect:controlled:${s.setter}`, {
+        kind: "effect",
+        name: `controlled:${s.setter}`,
+        loc: s.loc
+      });
+    }
+  }
+  for (const m of graph.memos) {
+    index.set(`${comp}#memo:${m.name}`, { kind: "memo", name: m.name, loc: m.loc });
+  }
+  for (const e of graph.effects) {
+    const node = { kind: "effect", name: e.label, loc: e.loc };
+    index.set(`${comp}#effect:${e.loc.line}`, node);
+    index.set(`${comp}#effect:${e.label}`, node);
+  }
+  for (const b of graph.domBindings) {
+    if (!b.loc)
+      continue;
+    const loc = { file: b.loc.file, line: b.loc.start.line };
+    if (b.type === "event") {
+      const eventName = b.label.match(/^(\w+)\s+handler/)?.[1];
+      if (eventName) {
+        index.set(`${comp}#handler:${b.slotId}:${eventName}`, {
+          kind: "handler",
+          name: `${eventName}@${b.slotId}`,
+          loc
+        });
+      }
+      continue;
+    }
+    index.set(`${comp}#binding:${b.slotId}`, { kind: "effect", name: `${b.slotId} (${b.type})`, loc });
+  }
+  return index;
+}
+function isRuntimeBookkeepingId(id) {
+  return /^[serm]\d+$/.test(id);
+}
+function isFallbackEffectId(id) {
+  return /^e\d+$/.test(id);
+}
+function joinProfilerEvents(events, index) {
+  const joined = [];
+  const gaps = new Map;
+  const resolve2 = (id) => {
+    if (id === undefined)
+      return;
+    const node = index.get(id);
+    if (!node)
+      gaps.set(id, (gaps.get(id) ?? 0) + 1);
+    return node;
+  };
+  for (const event of events) {
+    joined.push({
+      event,
+      subscriber: resolve2(event.subscriber),
+      signal: resolve2(event.signal)
+    });
+  }
+  const unattributed = [];
+  const diagnostics = [];
+  for (const [id, count] of gaps.entries()) {
+    (isRuntimeBookkeepingId(id) ? diagnostics : unattributed).push({ id, count });
+  }
+  const byCount = (a, b) => b.count - a.count;
+  unattributed.sort(byCount);
+  diagnostics.sort(byCount);
+  return { joined, unattributed, diagnostics };
+}
+function findUninstrumentedEffects(source, filePath, instrumentedLines) {
+  const sf = ts20.createSourceFile(filePath, source, ts20.ScriptTarget.Latest, true, ts20.ScriptKind.TSX);
+  const out = [];
+  const visit3 = (node) => {
+    if (ts20.isCallExpression(node) && ts20.isIdentifier(node.expression) && node.expression.text === "createEffect") {
+      const line = sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+      if (!instrumentedLines.has(line))
+        out.push({ file: filePath, line });
+    }
+    ts20.forEachChild(node, visit3);
+  };
+  visit3(sf);
+  out.sort((a, b) => a.line - b.line);
+  return out;
+}
+var DEFAULT_HOT_RUNS_PER_TURN = 2;
+function analyzeHotSubscribers(events, index, options = {}) {
+  const threshold = options.hotRunsPerTurn ?? DEFAULT_HOT_RUNS_PER_TURN;
+  const byId = new Map;
+  const acc = (id) => {
+    let a = byId.get(id);
+    if (!a) {
+      a = { runs: 0, mountRuns: 0, totalMs: 0, turns: new Set };
+      byId.set(id, a);
+    }
+    return a;
+  };
+  for (const e of events) {
+    if (e.subscriber === undefined)
+      continue;
+    if (e.type === "effectEnter") {
+      const a = acc(e.subscriber);
+      a.runs++;
+      if (e.turn === null)
+        a.mountRuns++;
+      else
+        a.turns.add(String(e.turnSeq ?? e.turn));
+    } else if (e.type === "effectExit" && e.dur !== undefined) {
+      acc(e.subscriber).totalMs += e.dur;
+    }
+  }
+  const { joined, unattributed } = joinProfilerEvents(events, index);
+  const nodeFor = new Map;
+  for (const j of joined) {
+    if (j.event.subscriber !== undefined && j.subscriber)
+      nodeFor.set(j.event.subscriber, j.subscriber);
+  }
+  let subscribers = [...byId.entries()].map(([subscriber, a]) => {
+    const node = nodeFor.get(subscriber);
+    const turns = a.turns.size;
+    const interactionRuns = a.runs - a.mountRuns;
+    const runsPerTurn = turns > 0 ? interactionRuns / turns : 0;
+    const uninstrumented = !node && isFallbackEffectId(subscriber);
+    return {
+      subscriber,
+      loc: node?.loc,
+      name: node?.name,
+      kind: node?.kind,
+      runs: a.runs,
+      mountRuns: a.mountRuns,
+      totalMs: a.totalMs,
+      turns,
+      runsPerTurn,
+      hot: runsPerTurn >= threshold,
+      ...uninstrumented ? {
+        resolution: "uninstrumented",
+        resolutionNote: "createEffect in non-JSX function scope (not attributed by compiler)",
+        candidates: [...options.uninstrumentedCandidates ?? []]
+      } : {}
+    };
+  });
+  const roundMs = (m) => Math.round(m * 10) / 10;
+  subscribers.sort((x, y) => roundMs(y.totalMs) - roundMs(x.totalMs) || y.runs - x.runs || (x.subscriber < y.subscriber ? -1 : x.subscriber > y.subscriber ? 1 : 0));
+  if (options.minMs !== undefined)
+    subscribers = subscribers.filter((s) => roundMs(s.totalMs) >= options.minMs);
+  if (options.topN !== undefined)
+    subscribers = subscribers.slice(0, options.topN);
+  const subscriberIds = new Set(byId.keys());
+  const gaps = unattributed.filter((u) => subscriberIds.has(u.id));
+  return { kind: "hot-subscribers", subscribers, unattributed: gaps };
+}
+var BAR_EIGHTHS = ["", "▏", "▎", "▍", "▌", "▋", "▊", "▉"];
+function fitLabel(s, width) {
+  return s.length > width ? `${s.slice(0, width - 1)}…` : s.padEnd(width);
+}
+function bar(value, max, width) {
+  if (max <= 0 || value <= 0)
+    return "".padEnd(width);
+  const units = Math.min(value / max, 1) * width;
+  let full = Math.floor(units);
+  let rem = Math.round((units - full) * 8);
+  if (rem === 8) {
+    full++;
+    rem = 0;
+  }
+  return ("█".repeat(full) + (rem > 0 ? BAR_EIGHTHS[rem] : "")).padEnd(width);
+}
+function formatEffectCandidates(candidates) {
+  const byFile = new Map;
+  for (const c of candidates) {
+    const arr = byFile.get(c.file) ?? [];
+    arr.push(c.line);
+    byFile.set(c.file, arr);
+  }
+  const groups = [];
+  for (const [file, ls] of byFile) {
+    const sorted = [...new Set(ls)].sort((a, b) => a - b);
+    groups.push(`${file}:${sorted[0]}${sorted.slice(1).map((l) => `, :${l}`).join("")}`);
+  }
+  return groups.join("; ");
+}
+function formatHotSubscribers(r, limit = 12) {
+  const lines = [];
+  lines.push("hot subscribers — most run / most time");
+  if (r.subscribers.length === 0) {
+    lines.push("  (no effect/memo runs recorded)");
+  }
+  const shown = r.subscribers.slice(0, limit);
+  const maxMs = shown.reduce((m, s) => Math.max(m, s.totalMs), 0);
+  for (const s of shown) {
+    const where = s.loc ? `${s.loc.file}:${s.loc.line}` : s.resolution === "uninstrumented" ? "uninstrumented — createEffect in non-JSX scope" : "unresolved";
+    const base = s.name ?? s.subscriber;
+    const label = s.kind && !base.endsWith(")") ? `${base} (${s.kind})` : base;
+    const note = s.hot ? `  ⚠ ${s.runsPerTurn.toFixed(1)}/turn` : "";
+    lines.push(`  ${fitLabel(label, 24)} ${bar(s.totalMs, maxMs, 14)} ${s.totalMs.toFixed(1)}ms  ${String(s.runs).padStart(3)}×  (${where})${note}`);
+    if (s.candidates && s.candidates.length > 0) {
+      lines.push(`${" ".repeat(26)}candidates: ${formatEffectCandidates(s.candidates)}`);
+    }
+  }
+  if (r.subscribers.length > shown.length) {
+    lines.push(`  … and ${r.subscribers.length - shown.length} more`);
+  }
+  if (r.unattributed.length > 0) {
+    lines.push(`  ⚠ coverage: ${r.unattributed.length} unresolved subscriber id(s)`);
+  }
+  return lines.join(`
+`);
+}
+var DEFAULT_WASTED_RATIO = 0.5;
+function analyzeWastedReReruns(events, index, options = {}) {
+  const threshold = options.wastedRatio ?? DEFAULT_WASTED_RATIO;
+  const byId = new Map;
+  for (const e of events) {
+    if (e.type !== "effectOutput" || e.subscriber === undefined || e.changed === undefined)
+      continue;
+    let a = byId.get(e.subscriber);
+    if (!a) {
+      a = { total: 0, wasted: 0 };
+      byId.set(e.subscriber, a);
+    }
+    a.total++;
+    if (!e.changed)
+      a.wasted++;
+  }
+  const { unattributed } = joinProfilerEvents(events, index);
+  const nodeFor = new Map;
+  for (const [id] of byId) {
+    const node = index.get(id);
+    if (node)
+      nodeFor.set(id, node);
+  }
+  let subscribers = [...byId.entries()].map(([subscriber, a]) => {
+    const node = nodeFor.get(subscriber);
+    const wastedRatio = a.total > 0 ? a.wasted / a.total : 0;
+    return {
+      subscriber,
+      loc: node?.loc,
+      name: node?.name,
+      kind: node?.kind,
+      totalRuns: a.total,
+      wastedRuns: a.wasted,
+      wastedRatio,
+      wasted: wastedRatio >= threshold
+    };
+  }).filter((s) => s.wastedRuns > 0);
+  subscribers.sort((x, y) => y.wastedRuns - x.wastedRuns || y.wastedRatio - x.wastedRatio || (x.subscriber < y.subscriber ? -1 : x.subscriber > y.subscriber ? 1 : 0));
+  if (options.topN !== undefined)
+    subscribers = subscribers.slice(0, options.topN);
+  const subscriberIds = new Set(byId.keys());
+  const gaps = unattributed.filter((u) => subscriberIds.has(u.id));
+  return { kind: "wasted-re-runs", subscribers, unattributed: gaps };
+}
+function wastedOutputNoun(kind) {
+  return kind === "memo" ? "identical value" : "identical DOM";
+}
+function formatWastedReReruns(r, limit = 12) {
+  const lines = [];
+  lines.push("wasted re-runs — re-ran but produced identical output");
+  if (r.subscribers.length === 0) {
+    lines.push("  (no wasted re-runs recorded)");
+  }
+  const shown = r.subscribers.slice(0, limit);
+  const maxWasted = shown.reduce((m, s) => Math.max(m, s.wastedRuns), 0);
+  for (const s of shown) {
+    const where = s.loc ? `${s.loc.file}:${s.loc.line}` : "(unresolved)";
+    const base = s.name ?? s.subscriber;
+    const label = s.kind && !base.endsWith(")") ? `${base} (${s.kind})` : base;
+    const pct = Math.round(s.wastedRatio * 100);
+    const note = s.wasted ? "  ⚠ split so it doesn’t re-run on unrelated changes" : "";
+    lines.push(`  ${fitLabel(label, 24)} ${bar(s.wastedRuns, maxWasted, 14)} wasted: ${s.wastedRuns}/${s.totalRuns} produced ${wastedOutputNoun(s.kind)} (${pct}%)  (${where})${note}`);
+  }
+  if (r.subscribers.length > shown.length) {
+    lines.push(`  … and ${r.subscribers.length - shown.length} more`);
+  }
+  if (r.unattributed.length > 0) {
+    lines.push(`  ⚠ coverage: ${r.unattributed.length} unresolved subscriber id(s)`);
+  }
+  return lines.join(`
+`);
+}
+function analyzeBatchAdvisor(events, index) {
+  const byInvocation = new Map;
+  const get = (e) => {
+    if (e.turn === null)
+      return;
+    const key = String(e.turnSeq ?? e.turn);
+    let acc = byInvocation.get(key);
+    if (!acc) {
+      acc = { handlerId: e.turn, totalRuns: 0, writes: 0, depth: 0, subscribers: new Set };
+      byInvocation.set(key, acc);
+    }
+    return acc;
+  };
+  for (const e of events) {
+    if (e.type === "signalSet") {
+      const acc = get(e);
+      if (acc && acc.depth === 0)
+        acc.writes++;
+    } else if (e.type === "effectEnter") {
+      const acc = get(e);
+      if (!acc)
+        continue;
+      acc.totalRuns++;
+      acc.depth++;
+      if (e.subscriber !== undefined)
+        acc.subscribers.add(e.subscriber);
+    } else if (e.type === "effectExit") {
+      const acc = get(e);
+      if (acc && acc.depth > 0)
+        acc.depth--;
+    }
+  }
+  const byHandler = new Map;
+  for (const acc of byInvocation.values()) {
+    if (acc.writes < 2)
+      continue;
+    const distinctSubscribers = acc.subscribers.size;
+    const savings = acc.totalRuns - distinctSubscribers;
+    if (savings <= 0)
+      continue;
+    const prev = byHandler.get(acc.handlerId);
+    if (prev && prev.savings >= savings)
+      continue;
+    const node = index?.get(acc.handlerId);
+    byHandler.set(acc.handlerId, {
+      turn: acc.handlerId,
+      loc: node?.loc,
+      handler: node?.name,
+      totalRuns: acc.totalRuns,
+      distinctSubscribers,
+      writes: acc.writes,
+      savings,
+      safety: "unverified"
+    });
+  }
+  const candidates = [...byHandler.values()];
+  candidates.sort((a, b) => b.savings - a.savings || b.totalRuns - a.totalRuns);
+  return { kind: "batch-advisor", candidates };
+}
+function formatBatchAdvisor(r) {
+  const lines = [];
+  lines.push("batch advisor — unbatched multi-write turns");
+  if (r.candidates.length === 0) {
+    lines.push("  (no turn would benefit from batching)");
+  }
+  const maxSavings = r.candidates.reduce((m, c) => Math.max(m, c.savings), 0);
+  for (const c of r.candidates) {
+    const safe = c.safety === "safe" ? ", safe" : c.safety === "unsafe" ? ", UNSAFE" : ", safety unverified";
+    const where = c.loc ? `  (${c.loc.file}:${c.loc.line})` : "";
+    const label = fitLabel(c.handler ?? c.turn, 24);
+    lines.push(`  ${label} ${bar(c.savings, maxSavings, 14)} batch candidate ${c.totalRuns}→${c.distinctSubscribers} (saves ${c.savings}${safe})${where}`);
+  }
+  return lines.join(`
+`);
+}
+function downstreamMemos(graph, written) {
+  const byName = new Map(graph.memos.map((m) => [m.name, m]));
+  const result = new Set;
+  const dependsOnWritten = (memoName, seen) => {
+    if (seen.has(memoName))
+      return false;
+    seen.add(memoName);
+    const m = byName.get(memoName);
+    if (!m)
+      return false;
+    for (const dep of m.deps) {
+      if (written.has(dep))
+        return true;
+      if (byName.has(dep) && dependsOnWritten(dep, seen))
+        return true;
+    }
+    return false;
+  };
+  for (const m of graph.memos)
+    if (dependsOnWritten(m.name, new Set))
+      result.add(m.name);
+  return result;
+}
+function assessBatchSafety(args) {
+  if (args.hasIndirectSetters || args.setterNames.length === 0)
+    return "unverified";
+  const D = downstreamMemos(args.graph, new Set(args.writtenSignals));
+  const setters = new Set(args.setterNames);
+  const memoNames = new Set(args.graph.memos.map((m) => m.name));
+  const signalGetters = new Set(args.graph.signals.map((s) => s.name));
+  let sf;
+  try {
+    sf = ts20.createSourceFile("__h.ts", `const __h = ${args.handler}`, ts20.ScriptTarget.Latest, true);
+  } catch {
+    return "unverified";
+  }
+  const calls = [];
+  const visit3 = (node) => {
+    if (ts20.isCallExpression(node) && ts20.isIdentifier(node.expression)) {
+      const name = node.expression.text;
+      if (setters.has(name))
+        calls.push({ pos: node.getStart(sf), kind: "write" });
+      else if (D.has(name) && node.arguments.length === 0)
+        calls.push({ pos: node.getStart(sf), kind: "memoRead" });
+      else if (!signalGetters.has(name) && !memoNames.has(name))
+        calls.push({ pos: node.getStart(sf), kind: "risky" });
+    }
+    ts20.forEachChild(node, visit3);
+  };
+  visit3(sf);
+  calls.sort((a, b) => a.pos - b.pos);
+  let seenWrite = false;
+  let risky = false;
+  for (const c of calls) {
+    if (c.kind === "write")
+      seenWrite = true;
+    else if (seenWrite && c.kind === "memoRead")
+      return "unsafe";
+    else if (seenWrite && c.kind === "risky")
+      risky = true;
+  }
+  if (!seenWrite)
+    return "unverified";
+  return risky ? "unverified" : "safe";
+}
+function turnToEventBinding(graph, events) {
+  const byLine = new Map;
+  for (const e of events)
+    if (e.loc)
+      byLine.set(e.loc.start.line, e);
+  const out = new Map;
+  for (const b of graph.domBindings) {
+    if (b.type !== "event" || !b.loc)
+      continue;
+    const eventName = b.label.match(/^(\w+)\s+handler/)?.[1];
+    const binding = byLine.get(b.loc.start.line);
+    if (eventName && binding)
+      out.set(`${graph.componentName}#handler:${b.slotId}:${eventName}`, binding);
+  }
+  return out;
+}
+function buildProfileReport(input) {
+  const { source, filePath, componentName, scenario, events } = input;
+  const primary = buildComponentAnalysis(source, filePath, componentName).graph;
+  const allSources = [{ source, filePath }, ...input.extraSources ?? []];
+  const index = new Map;
+  const turnBindings = new Map;
+  let handlersTotal = 0;
+  const instrumentedEffectLines = new Map;
+  for (const s of allSources) {
+    const program = createProgramForFile(s.source, s.filePath)?.program;
+    let componentNames;
+    try {
+      componentNames = listComponentFunctions(s.source, s.filePath);
+    } catch {
+      componentNames = [];
+    }
+    if (componentNames.length === 0)
+      componentNames = [undefined];
+    for (const name of componentNames) {
+      let graph;
+      try {
+        graph = buildComponentAnalysis(s.source, s.filePath, name, program).graph;
+      } catch {
+        continue;
+      }
+      for (const [k, v] of buildIdIndex(graph))
+        index.set(k, v);
+      for (const e of graph.effects) {
+        const set = instrumentedEffectLines.get(e.loc.file) ?? new Set;
+        set.add(e.loc.line);
+        instrumentedEffectLines.set(e.loc.file, set);
+      }
+      try {
+        const summary = buildEventSummary(s.source, s.filePath, name, program);
+        handlersTotal += summary.events.length;
+        for (const [turn, binding] of turnToEventBinding(graph, summary.events)) {
+          turnBindings.set(turn, { binding, graph });
+        }
+      } catch {}
+    }
+  }
+  const hasFallbackEffectId = events.some((e) => e.subscriber !== undefined && isFallbackEffectId(e.subscriber));
+  const uninstrumentedCandidates = [];
+  if (hasFallbackEffectId) {
+    for (const s of allSources) {
+      uninstrumentedCandidates.push(...findUninstrumentedEffects(s.source, s.filePath, instrumentedEffectLines.get(s.filePath) ?? new Set));
+    }
+  }
+  const hotSubscribers = analyzeHotSubscribers(events, index, {
+    topN: input.topN,
+    minMs: input.minMs,
+    uninstrumentedCandidates
+  });
+  const wastedReReruns = analyzeWastedReReruns(events, index, { wastedRatio: input.wastedRatio });
+  const batchAdvisor = analyzeBatchAdvisor(events, index);
+  const { unattributed, diagnostics } = joinProfilerEvents(events, index);
+  for (const c of batchAdvisor.candidates) {
+    const hit = turnBindings.get(c.turn);
+    if (!hit)
+      continue;
+    c.safety = assessBatchSafety({
+      handler: hit.binding.handler,
+      setterNames: hit.binding.setterCalls.map((s) => s.setter),
+      hasIndirectSetters: hit.binding.setterCalls.some((s) => s.via && s.via.length > 0),
+      writtenSignals: hit.binding.setterCalls.map((s) => s.signal).filter((s) => s !== null),
+      graph: hit.graph
+    });
+  }
+  const turnSeqs = new Set;
+  const handlerIds = new Set;
+  for (const e of events) {
+    if (e.turn !== null) {
+      turnSeqs.add(String(e.turnSeq ?? e.turn));
+      handlerIds.add(e.turn);
+    }
+  }
+  return {
+    kind: "profile",
+    componentName: primary.componentName,
+    sourceFile: primary.sourceFile,
+    scenario,
+    events: events.length,
+    turns: turnSeqs.size,
+    hotSubscribers,
+    wastedReReruns,
+    batchAdvisor,
+    coverage: {
+      handlersFired: handlerIds.size,
+      handlersTotal,
+      unattributed,
+      diagnostics: { count: diagnostics.length, sample: diagnostics.slice(0, 3).map((d) => d.id) }
+    }
+  };
+}
+function formatProfileReport(r) {
+  const lines = [];
+  lines.push(`${r.componentName} — profile (scenario: ${r.scenario})`);
+  lines.push(`  ${r.events} events across ${r.turns} turn(s)`);
+  if (r.turns === 0) {
+    lines.push(r.coverage.handlersTotal === 0 ? "  note: no event handlers — run `bf debug profile <component>` for the static budget." : "  note: no interactions measured (handlers are likely in composed children) — try `--scenario <story.tsx>`.");
+  }
+  lines.push("");
+  lines.push(formatHotSubscribers(r.hotSubscribers));
+  lines.push("");
+  lines.push(formatWastedReReruns(r.wastedReReruns));
+  lines.push("");
+  lines.push(formatBatchAdvisor(r.batchAdvisor));
+  lines.push("");
+  const c = r.coverage;
+  lines.push(`coverage: ${c.handlersFired}/${c.handlersTotal} handlers exercised`);
+  if (c.unattributed.length > 0) {
+    lines.push(`  ⚠ ${c.unattributed.length} unattributed id(s): ${c.unattributed.slice(0, 3).map((u) => u.id).join(", ")}`);
+  }
+  if (c.diagnostics.count > 0) {
+    lines.push(`  · ${c.diagnostics.count} anonymous runtime id(s) (non-actionable bookkeeping)`);
+  }
+  return lines.join(`
+`);
+}
+// src/debug-profile.ts
+var THRESHOLDS = {
+  highFanOut: 3,
+  deepMemoChain: 3,
+  fallbackHeavyMin: 3,
+  fallbackHeavyRatio: 0.5,
+  batchMinSignals: 2
+};
+function buildReactiveProfile(source, filePath, componentName) {
+  const graph = buildComponentGraph(source, filePath, componentName);
+  const eventSummary = buildEventSummary(source, filePath, componentName);
+  const hydrated = graph.signals.length > 0 || graph.memos.length > 0 || graph.effects.length > 0;
+  return buildProfileFromGraph(graph, eventSummary, hydrated);
+}
+function buildProfileFromGraph(graph, eventSummary, hydrated) {
+  const metrics = computeMetrics(graph, eventSummary, hydrated);
+  const findings = computeFindings(metrics, graph, eventSummary);
+  return { metrics, findings };
+}
+function computeMetrics(graph, eventSummary, hydrated) {
+  let maxFanOut = 0;
+  let hotSignal = null;
+  for (const signal of graph.signals) {
+    if (signal.consumers.length > maxFanOut) {
+      maxFanOut = signal.consumers.length;
+      hotSignal = signal.name;
+    }
+  }
+  const maxMemoChainDepth = computeMaxMemoChainDepth(graph);
+  const dynamicBindings = graph.domBindings.length;
+  const fallbacks = graph.domBindings.filter((d) => d.classification === "fallback").length;
+  const eventHandlers = graph.domBindings.filter((d) => d.type === "event").length;
+  const conditionals = graph.domBindings.filter((d) => d.type === "conditional").length;
+  const loops = graph.domBindings.filter((d) => d.type === "loop").length;
+  const totalSubscriptions = graph.memos.reduce((s, m) => s + m.deps.length, 0) + graph.effects.reduce((s, e) => s + e.deps.length, 0) + graph.domBindings.reduce((s, b) => s + b.deps.length, 0);
+  const batchDedupeKeys = new Set;
+  for (const event of eventSummary.events) {
+    const distinct = new Set;
+    for (const sc of event.setterCalls) {
+      if (sc.signal)
+        distinct.add(sc.signal);
+    }
+    if (distinct.size >= THRESHOLDS.batchMinSignals) {
+      const key = `${event.eventName}|${event.loc.file ?? ""}|${event.loc.start.line}|${[...distinct].sort().join(",")}`;
+      batchDedupeKeys.add(key);
+    }
+  }
+  const batchCandidateCount = batchDedupeKeys.size;
+  return {
+    componentName: graph.componentName,
+    sourceFile: graph.sourceFile,
+    hydrated,
+    signals: graph.signals.length,
+    memos: graph.memos.length,
+    effects: graph.effects.length,
+    loops,
+    eventHandlers,
+    dynamicBindings,
+    fallbacks,
+    conditionals,
+    maxSignalFanOut: maxFanOut,
+    hotSignal,
+    maxMemoChainDepth,
+    totalSubscriptions,
+    batchCandidateCount
+  };
+}
+function computeMaxMemoChainDepth(graph) {
+  if (graph.memos.length === 0)
+    return 0;
+  const memoSet = new Set(graph.memos.map((m) => m.name));
+  const memoDeps = new Map;
+  for (const memo of graph.memos) {
+    memoDeps.set(memo.name, memo.deps.filter((d) => memoSet.has(d)));
+  }
+  const cache = new Map;
+  function depth(name, visited) {
+    if (cache.has(name))
+      return cache.get(name);
+    if (visited.has(name))
+      return 0;
+    const children = memoDeps.get(name) ?? [];
+    if (children.length === 0) {
+      cache.set(name, 1);
+      return 1;
+    }
+    visited.add(name);
+    const d = 1 + Math.max(...children.map((c) => depth(c, new Set(visited))));
+    cache.set(name, d);
+    return d;
+  }
+  let max = 0;
+  for (const memo of graph.memos) {
+    const d = depth(memo.name, new Set);
+    if (d > max)
+      max = d;
+  }
+  return max;
+}
+function computeFindings(metrics, graph, eventSummary) {
+  const findings = [];
+  for (const signal of graph.signals) {
+    if (signal.consumers.length > THRESHOLDS.highFanOut) {
+      findings.push({
+        kind: "high-fan-out",
+        severity: "warning",
+        signal: signal.name,
+        message: `${signal.name} has ${signal.consumers.length} consumers (fan-out > ${THRESHOLDS.highFanOut})`,
+        suggestion: `Split ${signal.name} into finer-grained signals, or add a createMemo to shield downstream consumers from unrelated updates`,
+        loc: { file: signal.loc.file, line: signal.loc.line }
+      });
+    }
+  }
+  if (metrics.maxMemoChainDepth > THRESHOLDS.deepMemoChain) {
+    findings.push({
+      kind: "deep-memo-chain",
+      severity: "warning",
+      depth: metrics.maxMemoChainDepth,
+      message: `Memo chain depth ${metrics.maxMemoChainDepth} (threshold: ${THRESHOLDS.deepMemoChain}) — a single signal update cascades through ${metrics.maxMemoChainDepth} memo levels`,
+      suggestion: "Flatten intermediate memos that do not cache expensive computations; deep chains increase propagation latency"
+    });
+  }
+  const batchSeen = new Set;
+  for (const event of eventSummary.events) {
+    const distinct = new Set;
+    const setterNames = [];
+    for (const sc of event.setterCalls) {
+      if (sc.signal) {
+        distinct.add(sc.signal);
+        setterNames.push(sc.setter);
+      }
+    }
+    if (distinct.size >= THRESHOLDS.batchMinSignals) {
+      const dedupeKey = `${event.eventName}|${event.loc.file ?? ""}|${event.loc.start.line}|${[...distinct].sort().join(",")}`;
+      if (batchSeen.has(dedupeKey))
+        continue;
+      batchSeen.add(dedupeKey);
+      findings.push({
+        kind: "batch-candidate",
+        severity: "info",
+        signals: [...distinct],
+        message: `${event.eventName} on <${event.elementContext}> sets ${distinct.size} signals (${[...distinct].join(", ")}) — triggers ${distinct.size} separate update cycles (static; verify setters are not in separate if/else branches)`,
+        suggestion: `If all listed setters fire unconditionally in the same handler path, wrap in batch(() => { ${setterNames.join("; ")}; }) to collapse ${distinct.size} cycles into 1`,
+        loc: event.loc.file ? { file: event.loc.file, line: event.loc.start.line } : undefined
+      });
+    }
+  }
+  if (metrics.dynamicBindings > 0 && metrics.fallbacks >= THRESHOLDS.fallbackHeavyMin && metrics.fallbacks / metrics.dynamicBindings > THRESHOLDS.fallbackHeavyRatio) {
+    findings.push({
+      kind: "fallback-heavy",
+      severity: "info",
+      message: `${metrics.fallbacks}/${metrics.dynamicBindings} bindings (${Math.round(metrics.fallbacks / metrics.dynamicBindings * 100)}%) are fallback-wrapped — reactivity not statically provable`,
+      suggestion: "Run `bf debug fallbacks` to see each expression and fix them so the compiler can prove reactivity without the fallback wrapper"
+    });
+  }
+  return findings;
+}
+function diffProfiles(before, after) {
+  const worseWhenHigher = new Set([
+    "fallbacks",
+    "maxSignalFanOut",
+    "maxMemoChainDepth",
+    "totalSubscriptions",
+    "batchCandidateCount"
+  ]);
+  const numericKeys = [
+    "signals",
+    "memos",
+    "effects",
+    "loops",
+    "eventHandlers",
+    "dynamicBindings",
+    "fallbacks",
+    "conditionals",
+    "maxSignalFanOut",
+    "maxMemoChainDepth",
+    "totalSubscriptions",
+    "batchCandidateCount"
+  ];
+  const regressions = [];
+  const improvements = [];
+  const neutral = [];
+  for (const key of numericKeys) {
+    const b = before[key];
+    const a = after[key];
+    if (a === b)
+      continue;
+    const entry = { metric: key, before: b, after: a, delta: a - b };
+    if (worseWhenHigher.has(key)) {
+      if (a > b)
+        regressions.push(entry);
+      else
+        improvements.push(entry);
+    } else {
+      neutral.push(entry);
+    }
+  }
+  return { componentName: after.componentName, before, after, regressions, improvements, neutral };
+}
+function formatSingleProfile(profile) {
+  const m = profile.metrics;
+  const lines = [];
+  lines.push(`${m.componentName} — reactive profile (static)`);
+  if (m.sourceFile)
+    lines.push(`  source: ${m.sourceFile}`);
+  lines.push(`  hydrated: ${m.hydrated ? "yes" : "no"}`);
+  lines.push("");
+  lines.push("  Counts:");
+  lines.push(`    signals:          ${m.signals}`);
+  lines.push(`    memos:            ${m.memos}`);
+  if (m.effects > 0)
+    lines.push(`    effects:          ${m.effects}`);
+  lines.push(`    dynamic bindings: ${m.dynamicBindings}`);
+  if (m.fallbacks > 0)
+    lines.push(`    fallbacks:        ${m.fallbacks}`);
+  if (m.loops > 0)
+    lines.push(`    loops:            ${m.loops}`);
+  if (m.conditionals > 0)
+    lines.push(`    conditionals:     ${m.conditionals}`);
+  if (m.eventHandlers > 0)
+    lines.push(`    event handlers:   ${m.eventHandlers}`);
+  lines.push("");
+  lines.push("  Reactive budget (SR5):");
+  const fanOutSuffix = m.hotSignal ? ` (${m.hotSignal})` : "";
+  lines.push(`    max signal fan-out:   ${m.maxSignalFanOut}${fanOutSuffix}`);
+  lines.push(`    max memo chain depth: ${m.maxMemoChainDepth}`);
+  lines.push(`    total subscriptions:  ${m.totalSubscriptions}`);
+  if (m.batchCandidateCount > 0) {
+    lines.push(`    batch candidates:     ${m.batchCandidateCount} handler(s) set ≥2 signals`);
+  }
+  if (profile.findings.length > 0) {
+    lines.push("");
+    lines.push("  Findings:");
+    for (const f of profile.findings) {
+      const icon = f.severity === "warning" ? "⚠" : "→";
+      lines.push(`    ${icon} [${f.kind}] ${f.message}`);
+      lines.push(`      fix: ${f.suggestion}`);
+      if (f.loc) {
+        const file = f.loc.file.split("/").pop() ?? f.loc.file;
+        lines.push(`      at ${file}:${f.loc.line}`);
+      }
+    }
+  } else {
+    lines.push("");
+    lines.push("  No findings — component is within all thresholds.");
+  }
+  return lines.join(`
+`);
+}
+function formatProfileTable(profiles) {
+  if (profiles.length === 0)
+    return "No components found.";
+  const sorted = [...profiles].sort((a, b) => b.metrics.totalSubscriptions - a.metrics.totalSubscriptions);
+  const lines = [];
+  lines.push("Component               sig  memo  bind  fall  fanOut  chain  subs  batch  findings");
+  lines.push("─".repeat(90));
+  for (const p of sorted) {
+    const m = p.metrics;
+    const name = m.componentName.padEnd(23).slice(0, 23);
+    const findingStr = p.findings.length > 0 ? p.findings.map((f) => f.kind.replace(/-/g, "_")).join(",") : "—";
+    const row = [
+      name,
+      String(m.signals).padStart(3),
+      String(m.memos).padStart(5),
+      String(m.dynamicBindings).padStart(5),
+      String(m.fallbacks).padStart(5),
+      String(m.maxSignalFanOut).padStart(7),
+      String(m.maxMemoChainDepth).padStart(6),
+      String(m.totalSubscriptions).padStart(5),
+      String(m.batchCandidateCount).padStart(6),
+      `  ${findingStr}`
+    ].join("  ");
+    lines.push(row);
+  }
+  const allFindings = sorted.flatMap((p) => p.findings.map((f) => ({ component: p.metrics.componentName, finding: f })));
+  if (allFindings.length > 0) {
+    lines.push("");
+    lines.push("Findings:");
+    for (const { component, finding } of allFindings) {
+      const icon = finding.severity === "warning" ? "⚠" : "→";
+      lines.push(`  ${icon} ${component}: ${finding.message}`);
+      lines.push(`    fix: ${finding.suggestion}`);
+      if (finding.loc) {
+        const file = finding.loc.file.split("/").pop() ?? finding.loc.file;
+        lines.push(`    at ${file}:${finding.loc.line}`);
+      }
+    }
+  } else {
+    lines.push("");
+    lines.push("No findings across all components.");
+  }
+  return lines.join(`
+`);
+}
+function formatProfileDiff(diff) {
+  const lines = [];
+  lines.push(`${diff.componentName} — reactive profile diff (before → after)`);
+  lines.push("");
+  if (diff.regressions.length === 0 && diff.improvements.length === 0 && diff.neutral.length === 0) {
+    lines.push("  No changes in reactive metrics.");
+    return lines.join(`
+`);
+  }
+  if (diff.regressions.length > 0) {
+    lines.push("  Regressions (reactive cost increased):");
+    for (const e of diff.regressions) {
+      lines.push(`    ${e.metric}: ${e.before} → ${e.after}  (+${e.delta})`);
+    }
+  }
+  if (diff.improvements.length > 0) {
+    lines.push("  Improvements (reactive cost decreased):");
+    for (const e of diff.improvements) {
+      lines.push(`    ${e.metric}: ${e.before} → ${e.after}  (${e.delta})`);
+    }
+  }
+  if (diff.neutral.length > 0) {
+    lines.push("  Structural changes (count changes, no clear direction):");
+    for (const e of diff.neutral) {
+      const sign = (e.delta ?? 0) > 0 ? "+" : "";
+      lines.push(`    ${e.metric}: ${e.before} → ${e.after}  (${sign}${e.delta})`);
+    }
+  }
+  return lines.join(`
+`);
+}
+function profileToJSON(profile) {
+  return {
+    metrics: profile.metrics,
+    findings: profile.findings
+  };
+}
 // src/augment-inherited-props.ts
-import ts19 from "typescript";
+import ts21 from "typescript";
 function collectContextConsumers(metadata) {
   const constants = metadata.localConstants ?? [];
   const contextDefaults = new Map;
@@ -19252,39 +20923,39 @@ function collectContextConsumers(metadata) {
 }
 function parseUseContextArg(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts19.isCallExpression(expr))
+  if (!expr || !ts21.isCallExpression(expr))
     return null;
-  if (!ts19.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
+  if (!ts21.isIdentifier(expr.expression) || expr.expression.text !== "useContext")
     return null;
   if (expr.arguments.length !== 1)
     return null;
   const arg = expr.arguments[0];
-  return ts19.isIdentifier(arg) ? arg.text : null;
+  return ts21.isIdentifier(arg) ? arg.text : null;
 }
 function parseCreateContextDefault(source) {
   const expr = parseSingleExpression(source);
-  if (!expr || !ts19.isCallExpression(expr))
+  if (!expr || !ts21.isCallExpression(expr))
     return null;
   if (expr.arguments.length === 0)
     return null;
   const arg = expr.arguments[0];
-  if (ts19.isStringLiteral(arg) || ts19.isNoSubstitutionTemplateLiteral(arg))
+  if (ts21.isStringLiteral(arg) || ts21.isNoSubstitutionTemplateLiteral(arg))
     return arg.text;
-  if (ts19.isNumericLiteral(arg))
+  if (ts21.isNumericLiteral(arg))
     return Number(arg.text);
-  if (arg.kind === ts19.SyntaxKind.TrueKeyword)
+  if (arg.kind === ts21.SyntaxKind.TrueKeyword)
     return true;
-  if (arg.kind === ts19.SyntaxKind.FalseKeyword)
+  if (arg.kind === ts21.SyntaxKind.FalseKeyword)
     return false;
   return null;
 }
 function parseSingleExpression(source) {
-  const sf = ts19.createSourceFile("__ctx.ts", `(${source})`, ts19.ScriptTarget.Latest, false);
+  const sf = ts21.createSourceFile("__ctx.ts", `(${source})`, ts21.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts19.isExpressionStatement(stmt))
+  if (!stmt || !ts21.isExpressionStatement(stmt))
     return null;
   let e = stmt.expression;
-  while (ts19.isParenthesizedExpression(e))
+  while (ts21.isParenthesizedExpression(e))
     e = e.expression;
   return e;
 }
@@ -19359,28 +21030,28 @@ function augmentInheritedPropAccesses(ir) {
   }
 }
 function evalStringArrayJoin(source) {
-  const sf = ts19.createSourceFile("__join.ts", `const __x = (${source});`, ts19.ScriptTarget.Latest, false);
+  const sf = ts21.createSourceFile("__join.ts", `const __x = (${source});`, ts21.ScriptTarget.Latest, false);
   const stmt = sf.statements[0];
-  if (!stmt || !ts19.isVariableStatement(stmt))
+  if (!stmt || !ts21.isVariableStatement(stmt))
     return null;
   let node = stmt.declarationList.declarations[0]?.initializer;
-  while (node && ts19.isParenthesizedExpression(node))
+  while (node && ts21.isParenthesizedExpression(node))
     node = node.expression;
-  if (!node || !ts19.isCallExpression(node))
+  if (!node || !ts21.isCallExpression(node))
     return null;
   const callee = node.expression;
-  if (!ts19.isPropertyAccessExpression(callee))
+  if (!ts21.isPropertyAccessExpression(callee))
     return null;
   if (callee.name.text !== "join")
     return null;
   let recv = callee.expression;
-  while (ts19.isParenthesizedExpression(recv))
+  while (ts21.isParenthesizedExpression(recv))
     recv = recv.expression;
-  if (!ts19.isArrayLiteralExpression(recv))
+  if (!ts21.isArrayLiteralExpression(recv))
     return null;
   const parts = [];
   for (const el of recv.elements) {
-    if (ts19.isStringLiteral(el) || ts19.isNoSubstitutionTemplateLiteral(el)) {
+    if (ts21.isStringLiteral(el) || ts21.isNoSubstitutionTemplateLiteral(el)) {
       parts.push(el.text);
     } else {
       return null;
@@ -19389,7 +21060,7 @@ function evalStringArrayJoin(source) {
   let sep2 = ",";
   if (node.arguments.length >= 1) {
     const arg = node.arguments[0];
-    if (ts19.isStringLiteral(arg) || ts19.isNoSubstitutionTemplateLiteral(arg))
+    if (ts21.isStringLiteral(arg) || ts21.isNoSubstitutionTemplateLiteral(arg))
       sep2 = arg.text;
     else
       return null;
@@ -19397,11 +21068,11 @@ function evalStringArrayJoin(source) {
   return parts.join(sep2);
 }
 function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
-  if (!ts19.isElementAccessExpression(val))
+  if (!ts21.isElementAccessExpression(val))
     return null;
   const obj = val.expression;
   const arg = val.argumentExpression;
-  if (!ts19.isIdentifier(obj) || !ts19.isIdentifier(arg))
+  if (!ts21.isIdentifier(obj) || !ts21.isIdentifier(arg))
     return null;
   let indexPropName;
   let defaultKey;
@@ -19417,35 +21088,35 @@ function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
   const constInfo = localConstants.find((c) => c.name === obj.text && c.isModule);
   if (constInfo?.value === undefined)
     return null;
-  const sf = ts19.createSourceFile("__rec.ts", `(${constInfo.value})`, ts19.ScriptTarget.Latest, true);
+  const sf = ts21.createSourceFile("__rec.ts", `(${constInfo.value})`, ts21.ScriptTarget.Latest, true);
   if (sf.statements.length !== 1)
     return null;
   const stmt = sf.statements[0];
-  if (!ts19.isExpressionStatement(stmt))
+  if (!ts21.isExpressionStatement(stmt))
     return null;
   let parsed = stmt.expression;
-  while (ts19.isParenthesizedExpression(parsed))
+  while (ts21.isParenthesizedExpression(parsed))
     parsed = parsed.expression;
-  if (!ts19.isObjectLiteralExpression(parsed))
+  if (!ts21.isObjectLiteralExpression(parsed))
     return null;
   const entries = [];
   for (const prop of parsed.properties) {
-    if (!ts19.isPropertyAssignment(prop))
+    if (!ts21.isPropertyAssignment(prop))
       return null;
     let key;
-    if (ts19.isIdentifier(prop.name)) {
+    if (ts21.isIdentifier(prop.name)) {
       key = prop.name.text;
-    } else if (ts19.isStringLiteral(prop.name) || ts19.isNoSubstitutionTemplateLiteral(prop.name)) {
+    } else if (ts21.isStringLiteral(prop.name) || ts21.isNoSubstitutionTemplateLiteral(prop.name)) {
       key = prop.name.text;
     } else {
       return null;
     }
     let v = prop.initializer;
-    while (ts19.isParenthesizedExpression(v))
+    while (ts21.isParenthesizedExpression(v))
       v = v.expression;
-    if (ts19.isNumericLiteral(v)) {
+    if (ts21.isNumericLiteral(v)) {
       entries.push({ key, value: { kind: "number", text: v.text } });
-    } else if (ts19.isStringLiteral(v) || ts19.isNoSubstitutionTemplateLiteral(v)) {
+    } else if (ts21.isStringLiteral(v) || ts21.isNoSubstitutionTemplateLiteral(v)) {
       entries.push({ key, value: { kind: "string", text: v.text } });
     } else {
       return null;
@@ -19455,12 +21126,16 @@ function parseRecordIndexAccess(val, localConstants, propsParams, resolveKey) {
 }
 export {
   traceUpdatePath,
+  testAdapter,
   stringifyParsedExpr,
   rewriteImportsForTemplate,
   resolveSetters,
   resetCompilerCounters,
   renderImportMapHtml,
+  profileToJSON,
+  parseStyleObjectEntries,
   parseRecordIndexAccess,
+  parseProfilerId,
   parseExpression,
   parseBlockBody,
   needsTypeBasedDetection,
@@ -19468,7 +21143,9 @@ export {
   listComponentFunctions as listExportedComponents,
   listComponentFunctions,
   jsxToIR,
+  joinProfilerEvents,
   isSupported,
+  isLowerableObjectRestDestructure,
   isBooleanAttr,
   identifierPath,
   graphToJSON,
@@ -19479,15 +21156,25 @@ export {
   generateClientJsWithSourceMap,
   generateClientJs,
   formatWhyUpdate,
+  formatWastedReReruns,
   formatUpdatePath,
+  formatStaticBudget,
+  formatSingleProfile,
   formatSignalTrace,
+  formatProfileTable,
+  formatProfileReport,
+  formatProfileDiff,
   formatParamWithType,
   formatLoopSummary,
+  formatHotSubscribers,
   formatFallbackExplanations,
   formatEventSummary,
   formatError,
   formatComponentSummary,
   formatComponentGraph,
+  formatBudgetDiff,
+  formatBatchAdvisor,
+  findUninstrumentedEffects,
   findReachableNames,
   extractSsrDefaults,
   extractFunctionParams,
@@ -19499,6 +21186,8 @@ export {
   emitIRNode,
   emitAttrValue,
   disableCompilerInstrumentation,
+  diffStaticBudget,
+  diffProfiles,
   describeFallback,
   createProgramForFile,
   createProgramForCorpus,
@@ -19508,11 +21197,16 @@ export {
   combineParentChildClientJs,
   collectContextConsumers,
   buildWhyUpdate,
+  buildStaticBudget,
   buildSourceMapFromIR,
+  buildReactiveProfile,
+  buildProfileReport,
+  buildProfileFromGraph,
   buildMetadata,
   buildLoopSummary,
   buildLoopChainExpr,
   buildLocalFunctionSetterMap,
+  buildIdIndex,
   buildGraphFromIR,
   buildEventSummary,
   buildComponentSummary,
@@ -19520,8 +21214,12 @@ export {
   buildComponentAnalysis,
   augmentInheritedPropAccesses,
   applyCssLayerPrefix,
+  analyzeWastedReReruns,
+  analyzeHotSubscribers,
   analyzeComponent,
   analyzeClientNeeds,
+  analyzeBatchAdvisor,
+  TestAdapter,
   SourceMapGenerator,
   REACTIVE_PRIMITIVES,
   JsxAdapter,