@askrjs/askr 0.0.1 → 0.0.2

package/dist/{chunk-L7RL4LYV.js → chunk-MIPES65F.js}

@@ -1,12 +1,11 @@
 import {
   Fragment,
   init_jsx_runtime
-} from "./chunk-YNH3D4KW.js";
+} from "./chunk-KR6HG7HF.js";
 import {
   __esm,
-  __export,
-  __toCommonJS
-} from "./chunk-4CV4JOE5.js";
+  __export
+} from "./chunk-QECQ2TF6.js";
 
 // src/dev/invariant.ts
 function invariant(condition, message, context) {
@@ -267,17 +266,14 @@ var init_scheduler = __esm({
         if (this.flushVersion >= target) return Promise.resolve();
         return new Promise((resolve, reject) => {
           const timer = setTimeout(() => {
+            const ns = globalThis.__ASKR__ || {};
             const diag = {
               flushVersion: this.flushVersion,
               queueLen: this.q.length - this.head,
               running: this.running,
               inHandler: this.inHandler,
               bulk: isBulkCommitActive(),
-              globals: {
-                __ASKR_LAST_FASTPATH_STATS: globalThis.__ASKR_LAST_FASTPATH_STATS,
-                __ASKR_LAST_BULK_TEXT_FASTPATH_STATS: globalThis.__ASKR_LAST_BULK_TEXT_FASTPATH_STATS,
-                __ASKR_FASTPATH_COUNTERS: globalThis.__ASKR_FASTPATH_COUNTERS
-              }
+              namespace: ns
             };
             reject(
               new Error(
@@ -354,248 +350,6 @@ var init_scheduler = __esm({
   }
 });
 
-// src/runtime/fastlane.ts
-function enterBulkCommit() {
-  _bulkCommitActive = true;
-  _appliedParents = /* @__PURE__ */ new WeakSet();
-  try {
-    const cleared = globalScheduler.clearPendingSyncTasks?.() ?? 0;
-    if (process.env.NODE_ENV !== "production") {
-      const _g = globalThis;
-      _g.__ASKR_FASTLANE_CLEARED_TASKS = cleared;
-    }
-  } catch (err) {
-    if (process.env.NODE_ENV !== "production") throw err;
-  }
-}
-function exitBulkCommit() {
-  _bulkCommitActive = false;
-  _appliedParents = null;
-}
-function isBulkCommitActive2() {
-  return _bulkCommitActive;
-}
-function markFastPathApplied(parent) {
-  if (!_appliedParents) return;
-  try {
-    _appliedParents.add(parent);
-  } catch (e) {
-    void e;
-  }
-}
-function isFastPathApplied(parent) {
-  return !!(_appliedParents && _appliedParents.has(parent));
-}
-function classifyUpdate(instance, result) {
-  if (!result || typeof result !== "object" || !("type" in result))
-    return { useFastPath: false, reason: "not-vnode" };
-  const vnode = result;
-  if (vnode == null || typeof vnode.type !== "string")
-    return { useFastPath: false, reason: "not-intrinsic" };
-  const parent = instance.target;
-  if (!parent) return { useFastPath: false, reason: "no-root" };
-  const firstChild = parent.children[0];
-  if (!firstChild) return { useFastPath: false, reason: "no-first-child" };
-  if (firstChild.tagName.toLowerCase() !== String(vnode.type).toLowerCase())
-    return { useFastPath: false, reason: "root-tag-mismatch" };
-  const children = vnode.children || vnode.props?.children;
-  if (!Array.isArray(children))
-    return { useFastPath: false, reason: "no-children-array" };
-  for (let i = 0; i < children.length; i++) {
-    const c = children[i];
-    if (typeof c === "object" && c !== null && "type" in c && typeof c.type === "function") {
-      return { useFastPath: false, reason: "component-child-present" };
-    }
-  }
-  if (instance.mountOperations.length > 0)
-    return { useFastPath: false, reason: "pending-mounts" };
-  const oldKeyMap = getKeyMapForElement(firstChild);
-  const decision = isKeyedReorderFastPathEligible(
-    firstChild,
-    children,
-    oldKeyMap
-  );
-  if (!decision.useFastPath || decision.totalKeyed < 128)
-    return { ...decision, useFastPath: false, reason: "renderer-declined" };
-  return { ...decision, useFastPath: true };
-}
-function commitReorderOnly(instance, result) {
-  const evaluate2 = globalThis.__ASKR_RENDERER?.evaluate;
-  if (typeof evaluate2 !== "function") {
-    logger.warn(
-      "[Tempo][FASTPATH][DEV] renderer.evaluate not available; declining fast-lane"
-    );
-    return false;
-  }
-  const schedBefore = process.env.NODE_ENV !== "production" ? globalScheduler.getState() : null;
-  enterBulkCommit();
-  try {
-    globalScheduler.runWithSyncProgress(() => {
-      evaluate2(result, instance.target);
-      try {
-        const comp = (init_component(), __toCommonJS(component_exports));
-        if (typeof comp?.finalizeReadSubscriptions === "function") {
-          try {
-            comp.finalizeReadSubscriptions(instance);
-          } catch (e) {
-            if (process.env.NODE_ENV !== "production") throw e;
-          }
-        }
-      } catch (e) {
-        void e;
-      }
-    });
-    try {
-      const clearedAfter = globalScheduler.clearPendingSyncTasks?.() ?? 0;
-      if (process.env.NODE_ENV !== "production") {
-        const _g = globalThis;
-        _g.__ASKR_FASTLANE_CLEARED_AFTER = clearedAfter;
-      }
-    } catch (err) {
-      if (process.env.NODE_ENV !== "production") throw err;
-    }
-    if (process.env.NODE_ENV !== "production") {
-      const _g = globalThis;
-      const commitCount = _g.__ASKR_LAST_FASTPATH_COMMIT_COUNT ?? 0;
-      const invariants = {
-        commitCount,
-        mountOps: instance.mountOperations.length,
-        cleanupFns: instance.cleanupFns.length
-      };
-      _g.__ASKR_LAST_FASTLANE_INVARIANTS = invariants;
-      if (commitCount !== 1) {
-        throw new Error(
-          "Fast-lane invariant violated: expected exactly one DOM commit during reorder-only commit"
-        );
-      }
-      if (invariants.mountOps > 0) {
-        throw new Error(
-          "Fast-lane invariant violated: mount operations were registered during bulk commit"
-        );
-      }
-      if (invariants.cleanupFns > 0) {
-        throw new Error(
-          "Fast-lane invariant violated: cleanup functions were added during bulk commit"
-        );
-      }
-      const schedAfter = globalScheduler.getState();
-      if (schedBefore && schedAfter && // Only fail if outstanding tasks increased — consuming existing tasks is allowed
-      schedAfter.taskCount > schedBefore.taskCount) {
-        try {
-          console.error(
-            "[FASTLANE] schedBefore, schedAfter",
-            schedBefore,
-            schedAfter
-          );
-          console.error(
-            "[FASTLANE] enqueue logs",
-            globalThis.__ASKR_ENQUEUE_LOGS
-          );
-        } catch (e) {
-          void e;
-        }
-        throw new Error(
-          "Fast-lane invariant violated: scheduler enqueued leftover work during bulk commit"
-        );
-      }
-      let finalState = globalScheduler.getState();
-      const executing = globalScheduler.isExecuting();
-      const outstandingAfter = Math.max(
-        0,
-        finalState.taskCount - (executing ? 1 : 0)
-      );
-      if (outstandingAfter !== 0) {
-        if (process.env.NODE_ENV !== "production") {
-          let attempts = 0;
-          while (attempts < 5) {
-            const cleared = globalScheduler.clearPendingSyncTasks?.() ?? 0;
-            if (cleared === 0) break;
-            attempts++;
-          }
-          finalState = globalScheduler.getState();
-          const outstandingAfter2 = Math.max(
-            0,
-            finalState.taskCount - (globalScheduler.isExecuting() ? 1 : 0)
-          );
-          if (outstandingAfter2 !== 0) {
-            try {
-              const _g2 = globalThis;
-              console.error(
-                "[FASTLANE] Post-commit enqueue logs:",
-                _g2.__ASKR_ENQUEUE_LOGS
-              );
-              console.error(
-                "[FASTLANE] Cleared counts:",
-                _g2.__ASKR_FASTLANE_CLEARED_TASKS,
-                _g2.__ASKR_FASTLANE_CLEARED_AFTER
-              );
-            } catch (err) {
-              void err;
-            }
-            throw new Error(
-              `Fast-lane invariant violated: scheduler has ${finalState.taskCount} pending task(s) after commit`
-            );
-          }
-        } else {
-          globalScheduler.clearPendingSyncTasks?.();
-        }
-      }
-    }
-    return true;
-  } finally {
-    exitBulkCommit();
-    if (process.env.NODE_ENV !== "production") {
-      try {
-        const _g = globalThis;
-        _g.__ASKR_FASTLANE_BULK_FLAG_CHECK = isBulkCommitActive2();
-      } catch (e) {
-        void e;
-      }
-    }
-  }
-  if (process.env.NODE_ENV !== "production") {
-    const _g = globalThis;
-    if (_g.__ASKR_FASTLANE_BULK_FLAG_CHECK) {
-      delete _g.__ASKR_FASTLANE_BULK_FLAG_CHECK;
-      throw new Error(
-        "Fast-lane invariant violated: bulk commit flag still set after commit"
-      );
-    }
-  }
-}
-function tryRuntimeFastLaneSync(instance, result) {
-  const cls = classifyUpdate(instance, result);
-  if (!cls.useFastPath) return false;
-  try {
-    return commitReorderOnly(instance, result);
-  } catch (err) {
-    if (process.env.NODE_ENV !== "production") throw err;
-    return false;
-  }
-}
-var _bulkCommitActive, _appliedParents;
-var init_fastlane = __esm({
-  "src/runtime/fastlane.ts"() {
-    "use strict";
-    init_scheduler();
-    init_logger();
-    init_dom();
-    _bulkCommitActive = false;
-    _appliedParents = null;
-    if (typeof globalThis !== "undefined") {
-      const _g = globalThis;
-      _g.__ASKR_FASTLANE = {
-        isBulkCommitActive: isBulkCommitActive2,
-        enterBulkCommit,
-        exitBulkCommit,
-        tryRuntimeFastLaneSync,
-        markFastPathApplied,
-        isFastPathApplied
-      };
-    }
-  }
-});
-
 // src/runtime/context.ts
 function withContext(frame, fn) {
   const oldFrame = currentContextFrame;
@@ -621,9 +375,10 @@ function defineContext(defaultValue) {
     key,
     defaultValue,
     Scope: (props) => {
+      const value = props.value;
       return {
         type: ContextScopeComponent,
-        props: { key, value: props.value, children: props.children }
+        props: { key, value, children: props.children }
       };
     }
   };
@@ -659,29 +414,29 @@ function ContextScopeComponent(props) {
     parent: parentFrame,
     values: /* @__PURE__ */ new Map([[key, value]])
   };
+  function createFunctionChildInvoker(fn, frame, owner) {
+    return {
+      type: ContextFunctionChildInvoker,
+      props: { fn, __frame: frame, __owner: owner }
+    };
+  }
   if (Array.isArray(children)) {
     return children.map((child) => {
       if (typeof child === "function") {
-        return {
-          type: ContextFunctionChildInvoker,
-          props: {
-            fn: child,
-            __frame: newFrame,
-            __owner: getCurrentComponentInstance()
-          }
-        };
+        return createFunctionChildInvoker(
+          child,
+          newFrame,
+          getCurrentComponentInstance()
+        );
       }
       return markWithFrame(child, newFrame);
     });
   } else if (typeof children === "function") {
-    return {
-      type: ContextFunctionChildInvoker,
-      props: {
-        fn: children,
-        __frame: newFrame,
-        __owner: getCurrentComponentInstance()
-      }
-    };
+    return createFunctionChildInvoker(
+      children,
+      newFrame,
+      getCurrentComponentInstance()
+    );
   } else if (children) {
     return markWithFrame(children, newFrame);
   }
@@ -725,22 +480,126 @@ var init_context = __esm({
   }
 });
 
-// src/renderer/dom.ts
-function cleanupInstanceIfPresent(node) {
+// src/renderer/diag/index.ts
+function getDiagMap() {
+  try {
+    const root = globalThis;
+    if (!root.__ASKR_DIAG) root.__ASKR_DIAG = {};
+    return root.__ASKR_DIAG;
+  } catch (e) {
+    void e;
+    return {};
+  }
+}
+function __ASKR_set(key, value) {
+  try {
+    const g = getDiagMap();
+    g[key] = value;
+    try {
+      const root = globalThis;
+      try {
+        const ns = root.__ASKR__ || (root.__ASKR__ = {});
+        try {
+          ns[key] = value;
+        } catch (e) {
+          void e;
+        }
+      } catch (e) {
+        void e;
+      }
+    } catch (e) {
+      void e;
+    }
+  } catch (e) {
+    void e;
+  }
+}
+function __ASKR_incCounter(key) {
+  try {
+    const g = getDiagMap();
+    const prev = typeof g[key] === "number" ? g[key] : 0;
+    const next = prev + 1;
+    g[key] = next;
+    try {
+      const root = globalThis;
+      const ns = root.__ASKR__ || (root.__ASKR__ = {});
+      try {
+        const nsPrev = typeof ns[key] === "number" ? ns[key] : 0;
+        ns[key] = nsPrev + 1;
+      } catch (e) {
+        void e;
+      }
+    } catch (e) {
+      void e;
+    }
+  } catch (e) {
+    void e;
+  }
+}
+var init_diag = __esm({
+  "src/renderer/diag/index.ts"() {
+    "use strict";
+  }
+});
+
+// src/runtime/fastlane-shared.ts
+function isBulkCommitActive2() {
+  return _bulkCommitActive;
+}
+function markFastPathApplied(parent) {
+  if (!_appliedParents) return;
+  try {
+    _appliedParents.add(parent);
+  } catch (e) {
+    void e;
+  }
+}
+var _bulkCommitActive, _appliedParents;
+var init_fastlane_shared = __esm({
+  "src/runtime/fastlane-shared.ts"() {
+    "use strict";
+    _bulkCommitActive = false;
+    _appliedParents = null;
+  }
+});
+
+// src/renderer/types.ts
+function _isDOMElement(node) {
+  return typeof node === "object" && node !== null && "type" in node;
+}
+var init_types = __esm({
+  "src/renderer/types.ts"() {
+    "use strict";
+  }
+});
+
+// src/renderer/cleanup.ts
+function cleanupInstanceIfPresent(node, opts) {
   if (!node) return;
   if (!(node instanceof Element)) return;
+  const errors = [];
   try {
     const inst = node.__ASKR_INSTANCE;
     if (inst) {
-      cleanupComponent(inst);
+      try {
+        cleanupComponent(inst);
+      } catch (err) {
+        if (opts?.strict) errors.push(err);
+        else if (process.env.NODE_ENV !== "production")
+          logger.warn("[Askr] cleanupComponent failed:", err);
+      }
       try {
         delete node.__ASKR_INSTANCE;
       } catch (e) {
-        void e;
+        if (opts?.strict) errors.push(e);
+        else void e;
       }
     }
   } catch (err) {
-    void err;
+    if (opts?.strict) errors.push(err);
+    else if (process.env.NODE_ENV !== "production") {
+      logger.warn("[Askr] cleanupInstanceIfPresent failed:", err);
+    }
   }
   try {
     const descendants = node.querySelectorAll("*");
@@ -748,32 +607,57 @@ function cleanupInstanceIfPresent(node) {
       try {
         const inst = d.__ASKR_INSTANCE;
         if (inst) {
-          cleanupComponent(inst);
+          try {
+            cleanupComponent(inst);
+          } catch (err) {
+            if (opts?.strict) errors.push(err);
+            else if (process.env.NODE_ENV !== "production") {
+              logger.warn(
+                "[Askr] cleanupInstanceIfPresent descendant cleanup failed:",
+                err
+              );
+            }
+          }
           try {
             delete d.__ASKR_INSTANCE;
           } catch (e) {
-            void e;
+            if (opts?.strict) errors.push(e);
+            else void e;
           }
         }
       } catch (err) {
-        void err;
+        if (opts?.strict) errors.push(err);
+        else if (process.env.NODE_ENV !== "production") {
+          logger.warn(
+            "[Askr] cleanupInstanceIfPresent descendant cleanup failed:",
+            err
+          );
+        }
       }
     }
   } catch (err) {
-    void err;
+    if (opts?.strict) errors.push(err);
+    else if (process.env.NODE_ENV !== "production") {
+      logger.warn(
+        "[Askr] cleanupInstanceIfPresent descendant query failed:",
+        err
+      );
+    }
+  }
+  if (errors.length > 0) {
+    throw new AggregateError(errors, "cleanupInstanceIfPresent failed");
   }
 }
-function _isDOMElement(node) {
-  return typeof node === "object" && node !== null && "type" in node;
-}
-function getKeyMapForElement(el) {
-  return keyedElements.get(el);
+function cleanupInstancesUnder(node, opts) {
+  cleanupInstanceIfPresent(node, opts);
 }
 function removeElementListeners(element) {
   const map = elementListeners.get(element);
   if (map) {
     for (const [eventName, entry] of map) {
-      element.removeEventListener(eventName, entry.handler);
+      if (entry.options !== void 0)
+        element.removeEventListener(eventName, entry.handler, entry.options);
+      else element.removeEventListener(eventName, entry.handler);
     }
     elementListeners.delete(element);
   }
@@ -786,262 +670,42 @@ function removeAllListeners(root) {
     removeElementListeners(children[i]);
   }
 }
-function evaluate(node, target, context) {
-  if (!target) return;
-  if (context && domRanges.has(context)) {
-    const range = domRanges.get(context);
-    let current = range.start.nextSibling;
-    while (current && current !== range.end) {
-      const next = current.nextSibling;
-      current.remove();
-      current = next;
+var elementListeners;
+var init_cleanup = __esm({
+  "src/renderer/cleanup.ts"() {
+    "use strict";
+    init_component();
+    init_logger();
+    elementListeners = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// src/renderer/keyed.ts
+function getKeyMapForElement(el) {
+  return keyedElements.get(el);
+}
+function isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap) {
+  const keyedVnodes = [];
+  for (let i = 0; i < newChildren.length; i++) {
+    const child = newChildren[i];
+    if (typeof child === "object" && child !== null && "type" in child) {
+      const childObj = child;
+      if (childObj.key !== void 0) {
+        keyedVnodes.push({
+          key: childObj.key,
+          vnode: child
+        });
+      }
     }
-    const dom = createDOMNode(node);
-    if (dom) {
-      target.insertBefore(dom, range.end);
-    }
-  } else if (context) {
-    const start = document.createComment("component-start");
-    const end = document.createComment("component-end");
-    target.appendChild(start);
-    target.appendChild(end);
-    domRanges.set(context, { start, end });
-    const dom = createDOMNode(node);
-    if (dom) {
-      target.insertBefore(dom, end);
-    }
-  } else {
-    const vnode = node;
-    const firstChild = target.children[0];
-    if (firstChild && _isDOMElement(vnode) && typeof vnode.type === "string" && firstChild.tagName.toLowerCase() === vnode.type.toLowerCase()) {
-      const vnodeChildren = vnode.children || vnode.props?.children;
-      let isSimpleTextVNode = false;
-      let textContent;
-      if (!Array.isArray(vnodeChildren)) {
-        if (typeof vnodeChildren === "string" || typeof vnodeChildren === "number") {
-          isSimpleTextVNode = true;
-          textContent = String(vnodeChildren);
-        }
-      } else if (vnodeChildren.length === 1) {
-        const child = vnodeChildren[0];
-        if (typeof child === "string" || typeof child === "number") {
-          isSimpleTextVNode = true;
-          textContent = String(child);
-        }
-      }
-      if (isSimpleTextVNode && firstChild.childNodes.length === 1 && firstChild.firstChild?.nodeType === 3) {
-        firstChild.firstChild.data = textContent;
-      } else {
-        if (vnodeChildren) {
-          if (Array.isArray(vnodeChildren)) {
-            const hasKeys = vnodeChildren.some(
-              (child) => typeof child === "object" && child !== null && "key" in child
-            );
-            if (hasKeys) {
-              let oldKeyMap = keyedElements.get(firstChild);
-              if (!oldKeyMap) {
-                oldKeyMap = /* @__PURE__ */ new Map();
-              }
-              try {
-                if (process.env.ASKR_FORCE_BULK_POSREUSE === "1") {
-                  try {
-                    const keyedVnodes = [];
-                    for (let i = 0; i < vnodeChildren.length; i++) {
-                      const c = vnodeChildren[i];
-                      if (_isDOMElement(c) && c.key !== void 0) {
-                        keyedVnodes.push({
-                          key: c.key,
-                          vnode: c
-                        });
-                      }
-                    }
-                    if (keyedVnodes.length > 0 && keyedVnodes.length === vnodeChildren.length) {
-                      logger.warn(
-                        "[Askr][FASTPATH] forced positional bulk keyed reuse (evaluate-level)"
-                      );
-                      const stats = performBulkPositionalKeyedTextUpdate(
-                        firstChild,
-                        keyedVnodes
-                      );
-                      if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
-                        try {
-                          const gl = globalThis;
-                          gl.__ASKR_LAST_FASTPATH_STATS = stats;
-                          gl.__ASKR_LAST_FASTPATH_COMMIT_COUNT = 1;
-                          const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
-                          counters.bulkKeyedPositionalForced = (counters.bulkKeyedPositionalForced || 0) + 1;
-                          gl.__ASKR_FASTPATH_COUNTERS = counters;
-                        } catch (e) {
-                          void e;
-                        }
-                      }
-                      try {
-                        const map = /* @__PURE__ */ new Map();
-                        const children = Array.from(firstChild.children);
-                        for (let i = 0; i < children.length; i++) {
-                          const el = children[i];
-                          const k = el.getAttribute("data-key");
-                          if (k !== null) {
-                            map.set(k, el);
-                            const n = Number(k);
-                            if (!Number.isNaN(n)) map.set(n, el);
-                          }
-                        }
-                        keyedElements.set(firstChild, map);
-                      } catch (e) {
-                        void e;
-                      }
-                    } else {
-                      const newKeyMap = reconcileKeyedChildren(
-                        firstChild,
-                        vnodeChildren,
-                        oldKeyMap
-                      );
-                      keyedElements.set(firstChild, newKeyMap);
-                    }
-                  } catch (err) {
-                    logger.warn(
-                      "[Askr][FASTPATH] forced bulk path failed, falling back",
-                      err
-                    );
-                    const newKeyMap = reconcileKeyedChildren(
-                      firstChild,
-                      vnodeChildren,
-                      oldKeyMap
-                    );
-                    keyedElements.set(firstChild, newKeyMap);
-                  }
-                } else {
-                  const newKeyMap = reconcileKeyedChildren(
-                    firstChild,
-                    vnodeChildren,
-                    oldKeyMap
-                  );
-                  keyedElements.set(firstChild, newKeyMap);
-                }
-              } catch (e) {
-                void e;
-                const newKeyMap = reconcileKeyedChildren(
-                  firstChild,
-                  vnodeChildren,
-                  oldKeyMap
-                );
-                keyedElements.set(firstChild, newKeyMap);
-              }
-            } else {
-              if (isBulkTextFastPathEligible(firstChild, vnodeChildren)) {
-                const stats = performBulkTextReplace(firstChild, vnodeChildren);
-                if (process.env.NODE_ENV !== "production") {
-                  try {
-                    const gl = globalThis;
-                    gl.__ASKR_LAST_BULK_TEXT_FASTPATH_STATS = stats;
-                    const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
-                    counters.bulkTextHits = (counters.bulkTextHits || 0) + 1;
-                    gl.__ASKR_FASTPATH_COUNTERS = counters;
-                  } catch (e) {
-                    void e;
-                  }
-                }
-              } else {
-                if (process.env.NODE_ENV !== "production") {
-                  try {
-                    const gl = globalThis;
-                    const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
-                    counters.bulkTextMisses = (counters.bulkTextMisses || 0) + 1;
-                    gl.__ASKR_FASTPATH_COUNTERS = counters;
-                  } catch (e) {
-                    void e;
-                  }
-                }
-                updateUnkeyedChildren(firstChild, vnodeChildren);
-                keyedElements.delete(firstChild);
-              }
-            }
-          } else {
-            firstChild.textContent = "";
-            const dom = createDOMNode(vnodeChildren);
-            if (dom) firstChild.appendChild(dom);
-            keyedElements.delete(firstChild);
-          }
-        } else {
-          firstChild.textContent = "";
-          keyedElements.delete(firstChild);
-        }
-      }
-      updateElementFromVnode(firstChild, vnode, false);
-    } else {
-      target.textContent = "";
-      if (_isDOMElement(vnode) && typeof vnode.type === "string") {
-        const children = vnode.children;
-        if (Array.isArray(children) && children.some(
-          (child) => typeof child === "object" && child !== null && "key" in child
-        )) {
-          const el = document.createElement(vnode.type);
-          target.appendChild(el);
-          const props = vnode.props || {};
-          for (const [key, value] of Object.entries(props)) {
-            if (key === "children" || key === "key") continue;
-            if (value === void 0 || value === null || value === false)
-              continue;
-            if (key.startsWith("on") && key.length > 2) {
-              const eventName = key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();
-              const wrappedHandler = (event) => {
-                globalScheduler.setInHandler(true);
-                try {
-                  value(event);
-                } catch (error) {
-                  logger.error("[Askr] Event handler error:", error);
-                } finally {
-                  globalScheduler.setInHandler(false);
-                }
-              };
-              el.addEventListener(eventName, wrappedHandler);
-              if (!elementListeners.has(el)) {
-                elementListeners.set(el, /* @__PURE__ */ new Map());
-              }
-              elementListeners.get(el).set(eventName, {
-                handler: wrappedHandler,
-                original: value
-              });
-              continue;
-            }
-            if (key === "class" || key === "className") {
-              el.className = String(value);
-            } else if (key === "value" || key === "checked") {
-              el[key] = value;
-            } else {
-              el.setAttribute(key, String(value));
-            }
-          }
-          const newKeyMap = reconcileKeyedChildren(el, children, void 0);
-          keyedElements.set(el, newKeyMap);
-          return;
-          return;
-        }
-      }
-      const dom = createDOMNode(vnode);
-      if (dom) {
-        target.appendChild(dom);
-      }
-    }
-  }
-}
-function isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap) {
-  const keyedVnodes = [];
-  for (let i = 0; i < newChildren.length; i++) {
-    const child = newChildren[i];
-    if (_isDOMElement(child) && child.key !== void 0) {
-      keyedVnodes.push({ key: child.key, vnode: child });
-    }
-  }
-  const totalKeyed = keyedVnodes.length;
-  const newKeyOrder = keyedVnodes.map((kv) => kv.key);
-  const oldKeyOrder = oldKeyMap ? Array.from(oldKeyMap.keys()) : [];
-  let moveCount = 0;
-  for (let i = 0; i < newKeyOrder.length; i++) {
-    const k = newKeyOrder[i];
-    if (i >= oldKeyOrder.length || oldKeyOrder[i] !== k || !oldKeyMap?.has(k)) {
-      moveCount++;
+  }
+  const totalKeyed = keyedVnodes.length;
+  const newKeyOrder = keyedVnodes.map((kv) => kv.key);
+  const oldKeyOrder = oldKeyMap ? Array.from(oldKeyMap.keys()) : [];
+  let moveCount = 0;
+  for (let i = 0; i < newKeyOrder.length; i++) {
+    const k = newKeyOrder[i];
+    if (i >= oldKeyOrder.length || oldKeyOrder[i] !== k || !oldKeyMap?.has(k)) {
+      moveCount++;
     }
   }
   const FAST_MOVE_THRESHOLD_ABS = 64;
@@ -1082,8 +746,9 @@ function isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap) {
   let hasPropsPresent = false;
   for (let i = 0; i < keyedVnodes.length; i++) {
     const vnode = keyedVnodes[i].vnode;
-    if (!_isDOMElement(vnode)) continue;
-    const props = vnode.props || {};
+    if (typeof vnode !== "object" || vnode === null) continue;
+    const vnodeObj = vnode;
+    const props = vnodeObj.props || {};
     for (const k of Object.keys(props)) {
       if (k === "children" || k === "key") continue;
       if (k.startsWith("on") && k.length > 2) continue;
@@ -1097,8 +762,9 @@ function isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap) {
   for (let i = 0; i < keyedVnodes.length; i++) {
     const { key, vnode } = keyedVnodes[i];
     const el = oldKeyMap?.get(key);
-    if (!el || !_isDOMElement(vnode)) continue;
-    const props = vnode.props || {};
+    if (!el || typeof vnode !== "object" || vnode === null) continue;
+    const vnodeObj = vnode;
+    const props = vnodeObj.props || {};
     for (const k of Object.keys(props)) {
       if (k === "children" || k === "key") continue;
       if (k.startsWith("on") && k.length > 2) continue;
@@ -1127,8 +793,9 @@ function isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap) {
             break;
           }
         }
-      } catch {
+      } catch (e) {
         hasPropChanges = true;
+        void e;
         break;
       }
     }
@@ -1143,1024 +810,386 @@ function isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap) {
     hasPropChanges
   };
 }
-function reconcileKeyedChildren(parent, newChildren, oldKeyMap) {
-  const newKeyMap = /* @__PURE__ */ new Map();
-  const keyedVnodes = [];
-  const unkeyedVnodes = [];
-  for (let i = 0; i < newChildren.length; i++) {
-    const child = newChildren[i];
-    if (_isDOMElement(child) && child.key !== void 0) {
-      keyedVnodes.push({ key: child.key, vnode: child });
-    } else {
-      unkeyedVnodes.push(child);
-    }
+var keyedElements, _reconcilerRecordedParents;
+var init_keyed = __esm({
+  "src/renderer/keyed.ts"() {
+    "use strict";
+    keyedElements = /* @__PURE__ */ new WeakMap();
+    _reconcilerRecordedParents = /* @__PURE__ */ new WeakSet();
   }
-  const totalKeyed = keyedVnodes.length;
-  const newKeyOrder = keyedVnodes.map((kv) => kv.key);
-  const oldKeyOrder = oldKeyMap ? Array.from(oldKeyMap.keys()) : [];
-  let moveCount = 0;
-  for (let i = 0; i < newKeyOrder.length; i++) {
-    const k2 = newKeyOrder[i];
-    if (i >= oldKeyOrder.length || oldKeyOrder[i] !== k2 || !oldKeyMap?.has(k2)) {
-      moveCount++;
+});
+
+// src/renderer/dom.ts
+function createDOMNode(node) {
+  if (!IS_DOM_AVAILABLE) {
+    if (process.env.NODE_ENV !== "production") {
+      try {
+        logger.warn("[Askr] createDOMNode called in non-DOM environment");
+      } catch (e) {
+        void e;
+      }
     }
+    return null;
   }
-  let hasPropChanges = false;
-  for (let i = 0; i < keyedVnodes.length; i++) {
-    const { key, vnode } = keyedVnodes[i];
-    const el = oldKeyMap?.get(key);
-    if (!el || !_isDOMElement(vnode)) continue;
-    const props = vnode.props || {};
-    for (const k2 of Object.keys(props)) {
-      if (k2 === "children" || k2 === "key") continue;
-      if (k2.startsWith("on") && k2.length > 2) {
-        continue;
-      }
-      const v = props[k2];
-      try {
-        if (k2 === "class" || k2 === "className") {
-          if (el.className !== String(v)) {
-            logger.warn("[Askr][FASTPATH][DEV] prop mismatch", {
-              key,
-              prop: k2,
-              expected: String(v),
-              actual: el.className
-            });
-            hasPropChanges = true;
-            break;
-          }
-        } else if (k2 === "value" || k2 === "checked") {
-          if (el[k2] !== v) {
-            logger.warn("[Askr][FASTPATH][DEV] prop mismatch", {
-              key,
-              prop: k2,
-              expected: v,
-              actual: el[k2]
-            });
-            hasPropChanges = true;
-            break;
-          }
-        } else {
-          const attr = el.getAttribute(k2);
-          if (v === void 0 || v === null || v === false) {
-            if (attr !== null) {
-              logger.warn(
-                "[Askr][FASTPATH][DEV] prop mismatch (missing attr)",
-                {
-                  key,
-                  prop: k2,
-                  expected: v,
-                  actual: attr
-                }
-              );
-              hasPropChanges = true;
-              break;
-            }
-          } else if (String(v) !== attr) {
-            logger.warn("[Askr][FASTPATH][DEV] prop mismatch (attr diff)", {
-              key,
-              prop: k2,
-              expected: String(v),
-              actual: attr
-            });
-            hasPropChanges = true;
-            break;
-          }
-        }
-      } catch {
-        hasPropChanges = true;
-        break;
-      }
-    }
-    if (hasPropChanges) break;
-  }
-  const decision = isKeyedReorderFastPathEligible(
-    parent,
-    newChildren,
-    oldKeyMap
-  );
-  const useFastPath = decision.useFastPath;
-  logger.warn("[Askr][FASTPATH][DEV] decision", decision);
-  try {
-    const hugeThreshold = Number(process.env.ASKR_BULK_HUGE_THRESHOLD) || 2048;
-    if (!useFastPath && keyedVnodes.length >= hugeThreshold) {
-      let allSimple = true;
-      for (let i = 0; i < keyedVnodes.length; i++) {
-        const vnode = keyedVnodes[i].vnode;
-        if (!_isDOMElement(vnode)) {
-          allSimple = false;
-          break;
-        }
-        const dv = vnode;
-        if (typeof dv.type !== "string") {
-          allSimple = false;
-          break;
-        }
-        const ch = dv.children || dv.props?.children;
-        if (ch === void 0) continue;
-        if (Array.isArray(ch)) {
-          if (ch.length !== 1 || typeof ch[0] !== "string" && typeof ch[0] !== "number") {
-            allSimple = false;
-            break;
-          }
-        } else if (typeof ch !== "string" && typeof ch !== "number") {
-          allSimple = false;
-          break;
-        }
-      }
-      if (allSimple) {
-        logger.warn("[Askr][FASTPATH] applying huge-list positional fallback");
-        try {
-          if (isBulkCommitActive2()) markFastPathApplied(parent);
-        } catch (e) {
-          void e;
-        }
-        const stats = performBulkPositionalKeyedTextUpdate(parent, keyedVnodes);
-        if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
-          try {
-            const gl = globalThis;
-            gl.__ASKR_LAST_FASTPATH_STATS = stats;
-            const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
-            counters.bulkKeyedHugeFallback = (counters.bulkKeyedHugeFallback || 0) + 1;
-            gl.__ASKR_FASTPATH_COUNTERS = counters;
-            gl.__ASKR_BULK_DIAG = {
-              phase: "bulk-keyed-huge-fallback",
-              stats
-            };
-          } catch (e) {
-            void e;
-          }
-        }
-        return newKeyMap;
-      }
-    }
-  } catch (e) {
-    void e;
+  if (typeof node === "string") {
+    return document.createTextNode(node);
   }
-  if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
-    try {
-      const gl = globalThis;
-      gl.__ASKR_BULK_DIAG = {
-        phase: "keyed-decision",
-        decision,
-        totalKeyed,
-        oldKeyMapSize: oldKeyMap?.size ?? 0
-      };
-    } catch (e) {
-      void e;
-    }
+  if (typeof node === "number") {
+    return document.createTextNode(String(node));
   }
-  let allSimpleText = false;
-  try {
-    if (keyedVnodes.length >= (Number(process.env.ASKR_BULK_TEXT_THRESHOLD) || 1024)) {
-      let missing = 0;
-      try {
-        const present = /* @__PURE__ */ new Set();
-        const parentChildren2 = Array.from(parent.children);
-        for (let i = 0; i < parentChildren2.length; i++) {
-          const attr = parentChildren2[i].getAttribute("data-key");
-          if (attr !== null) {
-            present.add(attr);
-            const n = Number(attr);
-            if (!Number.isNaN(n)) present.add(n);
-          }
-        }
-        for (let i = 0; i < keyedVnodes.length; i++) {
-          const k2 = keyedVnodes[i].key;
-          if (!present.has(k2)) missing++;
-        }
-      } catch {
-        missing = 0;
-      }
-      allSimpleText = keyedVnodes.length > 0 && keyedVnodes.every(({ vnode }) => {
-        if (!_isDOMElement(vnode)) return false;
-        const dv = vnode;
-        if (typeof dv.type !== "string") return false;
-        const ch = dv.children || dv.props?.children;
-        if (ch === void 0) return true;
-        if (Array.isArray(ch)) {
-          return ch.length === 1 && (typeof ch[0] === "string" || typeof ch[0] === "number");
-        }
-        return typeof ch === "string" || typeof ch === "number";
-      });
-      let hasPropsPresent = false;
-      for (let i = 0; i < keyedVnodes.length; i++) {
-        const vnode = keyedVnodes[i].vnode;
-        if (!_isDOMElement(vnode)) continue;
-        const props = vnode.props || {};
-        for (const k2 of Object.keys(props)) {
-          if (k2 === "children" || k2 === "key") continue;
-          if (k2.startsWith("on") && k2.length > 2) continue;
-          if (k2.startsWith("data-")) continue;
-          hasPropsPresent = true;
-          break;
-        }
-        if (hasPropsPresent) break;
-      }
-      const missingRatio = missing / Math.max(1, keyedVnodes.length);
-      if (missingRatio > 0.5 && allSimpleText && !hasPropsPresent) {
-        logger.warn(
-          "[Askr][FASTPATH] switching to positional bulk keyed fast-path due to missing keys ratio",
-          missingRatio
-        );
-        try {
-          if (isBulkCommitActive2()) markFastPathApplied(parent);
-        } catch (e) {
-          void e;
-        }
-        const stats = performBulkPositionalKeyedTextUpdate(parent, keyedVnodes);
-        if (process.env.NODE_ENV !== "production") {
-          try {
-            const gl = globalThis;
-            gl.__ASKR_LAST_FASTPATH_STATS = stats;
-            try {
-              _reconcilerRecordedParents.add(parent);
-            } catch (e) {
-              void e;
-            }
-            gl.__ASKR_LAST_FASTPATH_COMMIT_COUNT = 1;
-            const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
-            counters.bulkKeyedPositionalHits = (counters.bulkKeyedPositionalHits || 0) + 1;
-            gl.__ASKR_FASTPATH_COUNTERS = counters;
-          } catch (e) {
-            void e;
-          }
-        }
-        return newKeyMap;
-      }
-    }
-  } catch (e) {
-    void e;
+  if (!node) {
+    return null;
   }
-  if (!useFastPath && typeof globalThis !== "undefined") {
-    try {
-      let parentFastpathApplied = false;
-      try {
-        parentFastpathApplied = isFastPathApplied(parent);
-      } catch {
-        parentFastpathApplied = false;
-      }
-      if (!parentFastpathApplied) {
-        const gl = globalThis;
-        try {
-          if (_reconcilerRecordedParents.has(parent)) {
-            _reconcilerRecordedParents.delete(parent);
-          } else {
-            delete gl.__ASKR_LAST_FASTPATH_STATS;
-            delete gl.__ASKR_LAST_FASTPATH_REUSED;
-          }
-        } catch {
-          delete gl.__ASKR_LAST_FASTPATH_STATS;
-          delete gl.__ASKR_LAST_FASTPATH_REUSED;
-        }
-      }
-    } catch (e) {
-      void e;
+  if (Array.isArray(node)) {
+    const fragment = document.createDocumentFragment();
+    for (let i = 0; i < node.length; i++) {
+      const dom = createDOMNode(node[i]);
+      if (dom) fragment.appendChild(dom);
     }
+    return fragment;
   }
-  let _triedPositionalReuse = false;
-  try {
-    const bulkTextThreshold = Number(process.env.ASKR_BULK_TEXT_THRESHOLD) || 1024;
-    if (!useFastPath && keyedVnodes.length >= bulkTextThreshold && allSimpleText && !hasPropChanges) {
-      try {
-        if (isFastPathApplied(parent)) {
-          logger.warn(
-            "[Askr][FASTPATH] fast-path already applied on parent; skipping"
-          );
-          return newKeyMap;
-        }
-      } catch (e) {
-        void e;
-      }
-      let stable = true;
-      try {
-        const parentChildren2 = Array.from(parent.children);
-        if (parentChildren2.length === keyedVnodes.length) {
-          const allSimple = keyedVnodes.every(({ vnode }) => {
-            if (!_isDOMElement(vnode)) return false;
-            const dv = vnode;
-            if (typeof dv.type !== "string") return false;
-            const ch = dv.children || dv.props?.children;
-            if (ch === void 0) return true;
-            if (Array.isArray(ch)) {
-              return ch.length === 1 && (typeof ch[0] === "string" || typeof ch[0] === "number");
-            }
-            return typeof ch === "string" || typeof ch === "number";
-          });
-          if (allSimple || process.env.ASKR_FORCE_BULK_POSREUSE === "1") {
-            logger.warn(
-              "[Askr][FASTPATH] len-match heuristic triggered (positional bulk)"
-            );
-            if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
-              try {
-                const gl = globalThis;
-                gl.__ASKR_BULK_DIAG = {
-                  phase: "bulk-keyed-positional-trigger-lenmatch-early",
-                  totalKeyed: keyedVnodes.length,
-                  allSimple,
-                  forced: process.env.ASKR_FORCE_BULK_POSREUSE === "1"
-                };
-              } catch (e) {
-                void e;
-              }
-            }
+  if (typeof node === "object" && node !== null && "type" in node) {
+    const type = node.type;
+    const props = node.props || {};
+    if (typeof type === "string") {
+      const el = document.createElement(type);
+      for (const key in props) {
+        const value = props[key];
+        if (key === "children" || key === "key") continue;
+        if (value === void 0 || value === null || value === false) continue;
+        if (key.startsWith("on") && key.length > 2) {
+          const eventName = key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();
+          const wrappedHandler = (event) => {
+            globalScheduler.setInHandler(true);
             try {
-              if (isBulkCommitActive2()) markFastPathApplied(parent);
-            } catch (e) {
-              void e;
-            }
-            const stats = performBulkPositionalKeyedTextUpdate(
-              parent,
-              keyedVnodes
-            );
-            if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
-              try {
-                const gl = globalThis;
-                gl.__ASKR_LAST_FASTPATH_STATS = stats;
-                gl.__ASKR_BULK_DIAG = {
-                  phase: "bulk-keyed-positional-applied",
-                  stats
-                };
-                const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
-                counters.bulkKeyedPositionalHits = (counters.bulkKeyedPositionalHits || 0) + 1;
-                if (process.env.ASKR_FORCE_BULK_POSREUSE === "1")
-                  counters.bulkKeyedPositionalForced = (counters.bulkKeyedPositionalForced || 0) + 1;
-                gl.__ASKR_FASTPATH_COUNTERS = counters;
-              } catch (e) {
-                void e;
+              value(event);
+            } catch (error) {
+              logger.error("[Askr] Event handler error:", error);
+            } finally {
+              globalScheduler.setInHandler(false);
+              const state = globalScheduler.getState();
+              if ((state.queueLength ?? 0) > 0 && !state.running) {
+                queueMicrotask(() => {
+                  try {
+                    if (!globalScheduler.isExecuting()) globalScheduler.flush();
+                  } catch (err) {
+                    queueMicrotask(() => {
+                      throw err;
+                    });
+                  }
+                });
               }
             }
-            return newKeyMap;
+          };
+          const options = eventName === "wheel" || eventName === "scroll" || eventName.startsWith("touch") ? { passive: true } : void 0;
+          if (options !== void 0)
+            el.addEventListener(eventName, wrappedHandler, options);
+          else el.addEventListener(eventName, wrappedHandler);
+          if (!elementListeners.has(el)) {
+            elementListeners.set(el, /* @__PURE__ */ new Map());
           }
-        }
-        if (parentChildren2.length !== keyedVnodes.length) stable = false;
-        else {
-          let keyMismatches = 0;
-          for (let i = 0; i < keyedVnodes.length; i++) {
-            const k2 = keyedVnodes[i].key;
-            const ch = parentChildren2[i];
-            if (!ch) {
-              stable = false;
-              break;
-            }
-            const attr = ch.getAttribute("data-key");
-            if (attr === null) {
-              stable = false;
-              break;
+          elementListeners.get(el).set(eventName, {
+            handler: wrappedHandler,
+            original: value,
+            options
+          });
+        } else if (key === "class" || key === "className") {
+          el.className = String(value);
+        } else if (key === "value" || key === "checked") {
+          const tag = type.toLowerCase();
+          if (key === "value") {
+            if (tag === "input" || tag === "textarea" || tag === "select") {
+              el.value = String(value);
+              el.setAttribute("value", String(value));
+            } else {
+              el.setAttribute("value", String(value));
             }
-            if (String(k2) !== attr && String(Number(attr)) !== String(k2)) {
-              keyMismatches++;
+          } else {
+            if (tag === "input") {
+              el.checked = Boolean(value);
+              el.setAttribute("checked", String(Boolean(value)));
+            } else {
+              el.setAttribute("checked", String(Boolean(value)));
             }
           }
-          if (stable) {
-            if (keyMismatches === 0) {
-              logger.warn(
-                "[Askr][FASTPATH] applying bulk keyed text fast-path (stable keys)"
-              );
-              if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
-                try {
-                  const gl = globalThis;
-                  gl.__ASKR_BULK_DIAG = {
-                    phase: "bulk-keyed-stable-trigger",
-                    totalKeyed: keyedVnodes.length,
-                    hasPropChanges
-                  };
-                } catch (e) {
-                  void e;
-                }
-              }
-              try {
-                if (isBulkCommitActive2()) markFastPathApplied(parent);
-              } catch (e) {
-                void e;
-              }
-              const stats = performBulkKeyedTextReplace(
-                parent,
-                keyedVnodes,
-                oldKeyMap
-              );
-              if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
-                try {
-                  const gl = globalThis;
-                  gl.__ASKR_LAST_FASTPATH_STATS = stats;
-                  gl.__ASKR_BULK_DIAG = {
-                    phase: "bulk-keyed-applied",
-                    stats
-                  };
-                  const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
-                  counters.bulkKeyedTextHits = (counters.bulkKeyedTextHits || 0) + 1;
-                  gl.__ASKR_FASTPATH_COUNTERS = counters;
-                } catch (e) {
-                  void e;
+        } else {
+          el.setAttribute(key, String(value));
+        }
+      }
+      const vnodeKey = node.key ?? props?.key;
+      if (vnodeKey !== void 0) {
+        el.setAttribute("data-key", String(vnodeKey));
+      }
+      const children = props.children || node.children;
+      if (children) {
+        if (Array.isArray(children)) {
+          if (process.env.NODE_ENV !== "production") {
+            let hasElements = false;
+            let hasKeys = false;
+            for (let i = 0; i < children.length; i++) {
+              const item = children[i];
+              if (typeof item === "object" && item !== null && "type" in item) {
+                hasElements = true;
+                const itemProps = item.props || {};
+                if ("key" in itemProps) {
+                  hasKeys = true;
+                  break;
                 }
               }
-              return newKeyMap;
             }
-            if (parentChildren2.length === keyedVnodes.length) {
-              logger.warn(
-                "[Askr][FASTPATH] applying bulk keyed positional text fast-path (len-match)"
-              );
-              if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
-                try {
-                  const gl = globalThis;
-                  gl.__ASKR_BULK_DIAG = {
-                    phase: "bulk-keyed-positional-trigger-lenmatch",
-                    totalKeyed: keyedVnodes.length,
-                    keyMismatches
-                  };
-                } catch (e) {
-                  void e;
-                }
-              }
-              try {
-                if (isBulkCommitActive2()) markFastPathApplied(parent);
-              } catch (e) {
-                void e;
-              }
-              const stats = performBulkPositionalKeyedTextUpdate(
-                parent,
-                keyedVnodes
-              );
-              if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+            if (hasElements && !hasKeys) {
+              if (typeof console !== "undefined") {
                 try {
-                  const gl = globalThis;
-                  gl.__ASKR_LAST_FASTPATH_STATS = stats;
-                  gl.__ASKR_BULK_DIAG = {
-                    phase: "bulk-keyed-positional-applied",
-                    stats
-                  };
-                  const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
-                  counters.bulkKeyedPositionalHits = (counters.bulkKeyedPositionalHits || 0) + 1;
-                  gl.__ASKR_FASTPATH_COUNTERS = counters;
+                  const inst = getCurrentInstance();
+                  const name = inst?.fn?.name || "<anonymous>";
+                  logger.warn(
+                    `Missing keys on dynamic lists in ${name}. Each child in a list should have a unique "key" prop.`
+                  );
                 } catch (e) {
+                  logger.warn(
+                    'Missing keys on dynamic lists. Each child in a list should have a unique "key" prop.'
+                  );
                   void e;
                 }
               }
-              return newKeyMap;
-            }
-            const mismatchRatio = keyMismatches / keyedVnodes.length;
-            const POSITIONAL_THRESHOLD = 0.5;
-            if (mismatchRatio > POSITIONAL_THRESHOLD) {
-              logger.warn(
-                "[Askr][FASTPATH] applying bulk keyed positional text fast-path"
-              );
-              if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
-                try {
-                  globalThis.__ASKR_BULK_DIAG = {
-                    phase: "bulk-keyed-positional-trigger",
-                    totalKeyed: keyedVnodes.length,
-                    keyMismatches
-                  };
-                } catch (e) {
-                  void e;
-                }
-              }
-              try {
-                if (isBulkCommitActive2()) markFastPathApplied(parent);
-              } catch (e) {
-                void e;
-              }
-              const stats = performBulkPositionalKeyedTextUpdate(
-                parent,
-                keyedVnodes
-              );
-              if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
-                try {
-                  const gl = globalThis;
-                  gl.__ASKR_LAST_FASTPATH_STATS = stats;
-                  gl.__ASKR_BULK_DIAG = {
-                    phase: "bulk-keyed-positional-applied",
-                    stats
-                  };
-                  const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
-                  counters.bulkKeyedPositionalHits = (counters.bulkKeyedPositionalHits || 0) + 1;
-                  gl.__ASKR_FASTPATH_COUNTERS = counters;
-                } catch (e) {
-                  void e;
-                }
-              }
-              return newKeyMap;
             }
           }
+          for (let i = 0; i < children.length; i++) {
+            const dom = createDOMNode(children[i]);
+            if (dom) el.appendChild(dom);
+          }
+        } else {
+          const dom = createDOMNode(children);
+          if (dom) el.appendChild(dom);
         }
-      } catch {
-        stable = false;
       }
+      return el;
     }
-  } catch (e) {
-    void e;
-  }
-  if (!useFastPath) {
-    const totalKeyed2 = keyedVnodes.length;
-    const candidates = newChildren.filter(
-      (c) => _isDOMElement(c) && typeof c.type === "string"
-    );
-    const smallListPositionalReuseEligible = candidates.length > 0 && candidates.length <= 64 && parent.children.length === candidates.length && candidates.every((vnode) => {
-      const children = vnode.children || vnode.props?.children;
-      if (Array.isArray(children)) {
-        return children.length === 1 && (typeof children[0] === "string" || typeof children[0] === "number");
+    if (typeof type === "function") {
+      const frame = node[CONTEXT_FRAME_SYMBOL];
+      const snapshot = frame || getCurrentContextFrame();
+      const componentFn = type;
+      const isAsync = componentFn.constructor.name === "AsyncFunction";
+      if (isAsync) {
+        throw new Error(
+          "Async components are not supported. Use resource() for async work."
+        );
       }
-      return children === void 0 || typeof children === "string" || typeof children === "number";
-    });
-    try {
-      if (smallListPositionalReuseEligible) {
-        let eligible = true;
-        for (let i = 0; i < totalKeyed2; i++) {
-          const vnode = keyedVnodes[i].vnode;
-          if (!_isDOMElement(vnode) || typeof vnode.type !== "string") {
-            eligible = false;
-            break;
-          }
-          const children = vnode.children || vnode.props?.children;
-          if (Array.isArray(children)) {
-            if (children.length !== 1) {
-              eligible = false;
-              break;
-            }
-            const c = children[0];
-            if (typeof c !== "string" && typeof c !== "number") {
-              eligible = false;
-              break;
-            }
-          } else if (children !== void 0 && typeof children !== "string" && typeof children !== "number") {
-            eligible = false;
-            break;
-          }
-        }
-        const anyKeyMatches = !!oldKeyMap && keyedVnodes.some((kv) => oldKeyMap.has(kv.key));
-        if (anyKeyMatches) {
-          eligible = false;
-        }
-        if (eligible || process.env.ASKR_FORCE_POSREUSE === "1") {
-          _triedPositionalReuse = true;
-          if (process.env.ASKR_FORCE_POSREUSE === "1") {
-            logger.warn(
-              "[Askr][POSREUSE][FORCED] forcing positional reuse path for testing"
-            );
-          } else {
-            logger.warn("[Askr][POSREUSE] positional reuse heuristic applied");
-          }
-          const existingChildren = parent.children;
-          for (let i = 0; i < totalKeyed2; i++) {
-            const { key, vnode } = keyedVnodes[i];
-            const current = existingChildren[i];
-            if (current && _isDOMElement(vnode)) {
-              const vnodeType = vnode.type;
-              if (current.tagName.toLowerCase() === vnodeType.toLowerCase()) {
-                updateElementFromVnode(current, vnode);
-                newKeyMap.set(key, current);
-                continue;
-              }
-            }
-            const newEl = createDOMNode(vnode);
-            if (newEl instanceof Element) {
-              if (current) {
-                cleanupInstanceIfPresent(current);
-                parent.replaceChild(newEl, current);
-              } else parent.appendChild(newEl);
-              newKeyMap.set(key, newEl);
-            }
-          }
-          for (const vnode of unkeyedVnodes) {
-            const newEl = createDOMNode(vnode);
-            if (newEl) parent.appendChild(newEl);
-          }
-          return newKeyMap;
-        }
+      const vnodeAny = node;
+      let childInstance = vnodeAny.__instance;
+      if (!childInstance) {
+        childInstance = createComponentInstance(
+          `comp-${Math.random().toString(36).slice(2, 7)}`,
+          componentFn,
+          props || {},
+          null
+        );
+        vnodeAny.__instance = childInstance;
       }
-    } catch {
-    }
-  }
-  if (useFastPath) {
-    if (!isSchedulerExecuting()) {
-      logger.warn(
-        "[Askr][FASTPATH][DEV] Fast-path reconciliation invoked outside scheduler execution"
+      if (snapshot) {
+        childInstance.ownerFrame = snapshot;
+      }
+      const result = withContext(
+        snapshot,
+        () => renderComponentInline(childInstance)
       );
-    }
-    let parentChildrenArr;
-    let localOldKeyMap;
-    if (totalKeyed <= 20) {
-      try {
-        const pc = parent.children;
-        parentChildrenArr = new Array(pc.length);
-        for (let i = 0; i < pc.length; i++)
-          parentChildrenArr[i] = pc[i];
-      } catch {
-        parentChildrenArr = void 0;
+      if (result instanceof Promise) {
+        throw new Error(
+          "Async components are not supported. Components must return synchronously."
+        );
       }
-    } else {
-      localOldKeyMap = /* @__PURE__ */ new Map();
-      try {
-        const parentChildren2 = Array.from(parent.children);
-        for (let i = 0; i < parentChildren2.length; i++) {
-          const ch = parentChildren2[i];
-          const k2 = ch.getAttribute("data-key");
-          if (k2 !== null) {
-            localOldKeyMap.set(k2, ch);
-            const n = Number(k2);
-            if (!Number.isNaN(n)) localOldKeyMap.set(n, ch);
-          }
-        }
-      } catch {
-        localOldKeyMap = void 0;
+      const dom = withContext(snapshot, () => createDOMNode(result));
+      if (dom instanceof Element) {
+        mountInstanceInline(childInstance, dom);
+        return dom;
       }
+      const host = document.createElement("div");
+      if (dom instanceof DocumentFragment) {
+        host.appendChild(dom);
+      } else if (dom) {
+        host.appendChild(dom);
+      }
+      mountInstanceInline(childInstance, host);
+      return host;
     }
-    logger.warn(
-      "[Askr][FASTPATH] oldKeyMap size:",
-      oldKeyMap?.size ?? 0,
-      "localOldKeyMap size:",
-      localOldKeyMap?.size
-    );
-    const tLookupStart = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
-    const finalNodes = [];
-    let mapLookups = 0;
-    let createdNodes = 0;
-    let reusedCount = 0;
-    for (let i = 0; i < keyedVnodes.length; i++) {
-      const { key, vnode } = keyedVnodes[i];
-      mapLookups++;
-      let el;
-      if (totalKeyed <= 20 && parentChildrenArr) {
-        const ks = String(key);
-        for (let j = 0; j < parentChildrenArr.length; j++) {
-          const ch = parentChildrenArr[j];
-          const k2 = ch.getAttribute("data-key");
-          if (k2 !== null && (k2 === ks || Number(k2) === key)) {
-            el = ch;
-            break;
+    if (typeof type === "symbol" && (type === Fragment || String(type) === "Symbol(Fragment)")) {
+      const fragment = document.createDocumentFragment();
+      const children = props.children || node.children;
+      if (children) {
+        if (Array.isArray(children)) {
+          for (let i = 0; i < children.length; i++) {
+            const dom = createDOMNode(children[i]);
+            if (dom) fragment.appendChild(dom);
           }
+        } else {
+          const dom = createDOMNode(children);
+          if (dom) fragment.appendChild(dom);
         }
-        if (!el) el = oldKeyMap?.get(key);
-      } else {
-        el = localOldKeyMap?.get(key) ?? oldKeyMap?.get(key);
       }
-      if (el) {
-        finalNodes.push(el);
-        reusedCount++;
-      } else {
-        const newEl = createDOMNode(vnode);
-        if (newEl) {
-          finalNodes.push(newEl);
-          createdNodes++;
+      return fragment;
+    }
+  }
+  return null;
+}
+function updateElementFromVnode(el, vnode, updateChildren = true) {
+  if (!_isDOMElement(vnode)) {
+    return;
+  }
+  const props = vnode.props || {};
+  const vnodeKey = vnode.key ?? vnode.props?.key;
+  if (vnodeKey !== void 0) {
+    el.setAttribute("data-key", String(vnodeKey));
+  }
+  const existingListeners = elementListeners.get(el);
+  const desiredEventNames = /* @__PURE__ */ new Set();
+  for (const key in props) {
+    const value = props[key];
+    if (key === "children" || key === "key") continue;
+    if (value === void 0 || value === null || value === false) {
+      if (key === "class" || key === "className") {
+        el.className = "";
+      } else if (key.startsWith("on") && key.length > 2) {
+        const eventName = key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();
+        if (existingListeners && existingListeners.has(eventName)) {
+          const entry = existingListeners.get(eventName);
+          if (entry.options !== void 0)
+            el.removeEventListener(eventName, entry.handler, entry.options);
+          else el.removeEventListener(eventName, entry.handler);
+          existingListeners.delete(eventName);
         }
+        continue;
+      } else {
+        el.removeAttribute(key);
       }
+      continue;
     }
-    for (const vnode of unkeyedVnodes) {
-      const newEl = createDOMNode(vnode);
-      if (newEl) {
-        finalNodes.push(newEl);
-        createdNodes++;
+    if (key === "class" || key === "className") {
+      el.className = String(value);
+    } else if (key === "value" || key === "checked") {
+      el[key] = value;
+    } else if (key.startsWith("on") && key.length > 2) {
+      const eventName = key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();
+      desiredEventNames.add(eventName);
+      const existing = existingListeners?.get(eventName);
+      if (existing && existing.original === value) {
+        continue;
       }
-    }
-    const t_lookup = typeof performance !== "undefined" && performance.now ? performance.now() - tLookupStart : 0;
-    if (process.env.ASKR_FASTPATH_GUARD === "1") {
-      const replaceChildrenCount = 0;
-      const otherMutationCount = 0;
-      const orig = {};
-      const elProto = Element.prototype;
-      const nodeProto = Node.prototype;
-      const removeFn = (() => {
-        if (typeof document === "undefined" || typeof document.createElement !== "function")
-          return void 0;
+      if (existing) {
+        el.removeEventListener(eventName, existing.handler);
+      }
+      const wrappedHandler = (event) => {
+        globalScheduler.setInHandler(true);
         try {
-          const el = document.createElement("div");
-          return typeof el.remove === "function" ? el.remove : void 0;
-        } catch {
-          return void 0;
-        }
-      })();
-      if (elProto.replaceChildren)
-        orig.replaceChildren = elProto.replaceChildren;
-      if (nodeProto.appendChild) orig.appendChild = nodeProto.appendChild;
-      if (nodeProto.insertBefore) orig.insertBefore = nodeProto.insertBefore;
-      if (nodeProto.removeChild) orig.removeChild = nodeProto.removeChild;
-      if (nodeProto.replaceChild) orig.replaceChild = nodeProto.replaceChild;
-      if (removeFn) orig.remove = removeFn;
-      let violation = false;
-      try {
-        const fragment = document.createDocumentFragment();
-        for (let i = 0; i < finalNodes.length; i++)
-          fragment.appendChild(finalNodes[i]);
-        let commitCount = 0;
-        commitCount++;
-        parent.replaceChildren(fragment);
-        if (typeof globalThis !== "undefined") {
-          globalThis["__ASKR_LAST_FASTPATH_COMMIT_COUNT"] = commitCount;
+          value(event);
+        } catch (error) {
+          logger.error("[Askr] Event handler error:", error);
+        } finally {
+          globalScheduler.setInHandler(false);
         }
-      } finally {
-        violation = otherMutationCount !== 0 || replaceChildrenCount < 1;
-      }
-      if (violation) {
-        logger.error(
-          "[Askr][DEV] Fast-path structural mutation invariant violated:",
-          {
-            replaceChildrenCount,
-            otherMutationCount
-          }
-        );
-        throw new Error(
-          "Fast-path must perform a single structural replacement (replaceChildren) and no other structural mutations"
-        );
+      };
+      const options = eventName === "wheel" || eventName === "scroll" || eventName.startsWith("touch") ? { passive: true } : void 0;
+      if (options !== void 0)
+        el.addEventListener(eventName, wrappedHandler, options);
+      else el.addEventListener(eventName, wrappedHandler);
+      if (!elementListeners.has(el)) {
+        elementListeners.set(el, /* @__PURE__ */ new Map());
       }
+      elementListeners.get(el).set(eventName, {
+        handler: wrappedHandler,
+        original: value,
+        options
+      });
     } else {
-      const tFragmentStart = Date.now();
-      const fragment = document.createDocumentFragment();
-      let fragmentAppendCount = 0;
-      for (let i = 0; i < finalNodes.length; i++) {
-        fragment.appendChild(finalNodes[i]);
-        fragmentAppendCount++;
-      }
-      const t_fragment = Date.now() - tFragmentStart;
-      const schedBefore = process.env.NODE_ENV !== "production" ? globalScheduler.getState() : null;
-      const wasExecuting = process.env.NODE_ENV !== "production" ? isSchedulerExecuting() : false;
-      const tCommitStart = Date.now();
-      if (process.env.NODE_ENV !== "production") {
-      }
-      let commitCount = 0;
-      commitCount++;
-      try {
-        const existing = Array.from(parent.childNodes);
-        for (const n of existing) cleanupInstanceIfPresent(n);
-      } catch (e) {
-        void e;
-      }
-      try {
-        const existing = Array.from(parent.childNodes);
-        for (const n of existing) cleanupInstanceIfPresent(n);
-      } catch (e) {
-        void e;
-      }
-      parent.replaceChildren(fragment);
-      if (typeof globalThis !== "undefined") {
-        globalThis["__ASKR_LAST_FASTPATH_COMMIT_COUNT"] = commitCount;
-      }
-      const t_commit = Date.now() - tCommitStart;
-      if (process.env.NODE_ENV !== "production") {
-        const schedAfter = globalScheduler.getState();
-        if (!wasExecuting) {
-          logger.warn(
-            "[Askr][FASTPATH][DEV] Fast-path commit invoked outside scheduler execution"
-          );
-        }
-        if (schedBefore && schedAfter) {
-          if (schedBefore.taskCount !== schedAfter.taskCount) {
-            logger.error(
-              "[Askr][FASTPATH][DEV] Scheduler tasks were enqueued during fast-path commit",
-              {
-                before: schedBefore,
-                after: schedAfter
-              }
-            );
-            throw new Error("Fast-path must not enqueue scheduler tasks");
-          }
-        }
-        const parentNodes = Array.from(parent.childNodes);
-        if (parentNodes.length !== finalNodes.length) {
-          logger.error("[Askr][FASTPATH][DEV] Parent child count mismatch", {
-            parentCount: parentNodes.length,
-            expected: finalNodes.length
-          });
-          throw new Error(
-            "Fast-path must perform a single structural replacement"
-          );
-        }
-        for (let i = 0; i < finalNodes.length; i++) {
-          if (parentNodes[i] !== finalNodes[i]) {
-            logger.error(
-              "[Askr][FASTPATH][DEV] Final DOM order mismatch at index",
-              i,
-              {
-                expected: finalNodes[i],
-                found: parentNodes[i]
-              }
-            );
-            throw new Error(
-              "Fast-path final DOM order does not match expected nodes"
-            );
-          }
-        }
-      }
-      const tBookkeepingStart = Date.now();
-      for (let i = 0; i < keyedVnodes.length; i++) {
-        const key = keyedVnodes[i].key;
-        const node = finalNodes[i];
-        if (node instanceof Element) newKeyMap.set(key, node);
-      }
-      const t_bookkeeping = Date.now() - tBookkeepingStart;
-      if (process.env.ASKR_FASTPATH_TRACE === "1" || process.env.NODE_ENV !== "production") {
-        const stats = {
-          n: totalKeyed,
-          moves: moveCount,
-          lisLen: 0,
-          t_lookup,
-          t_fragment,
-          t_commit,
-          t_bookkeeping,
-          fragmentAppendCount,
-          mapLookups,
-          createdNodes,
-          reusedCount
-        };
-        if (typeof globalThis !== "undefined") {
-          const _g = globalThis;
-          _g["__ASKR_LAST_FASTPATH_STATS"] = stats;
-          _g["__ASKR_LAST_FASTPATH_REUSED"] = reusedCount > 0;
-          const historyKey = "__ASKR_LAST_FASTPATH_HISTORY";
-          let hist = _g[historyKey];
-          if (!hist) {
-            hist = [];
-            _g[historyKey] = hist;
-          }
-          hist.push(stats);
-        }
-        logger.warn("[Askr][FASTPATH]", JSON.stringify(stats));
-      }
+      el.setAttribute(key, String(value));
     }
-    return newKeyMap;
   }
-  const parentChildren = Array.from(parent.children);
-  const positions = new Array(keyedVnodes.length).fill(-1);
-  for (let i = 0; i < keyedVnodes.length; i++) {
-    const key = keyedVnodes[i].key;
-    const el = oldKeyMap?.get(key);
-    if (el && el.parentElement === parent) {
-      positions[i] = parentChildren.indexOf(el);
-    }
-  }
-  const tailsStart = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
-  const keepSet = /* @__PURE__ */ new Set();
-  const tails = [];
-  const tailsIdx = [];
-  const prev = new Array(positions.length).fill(-1);
-  for (let i = 0; i < positions.length; i++) {
-    const pos = positions[i];
-    if (pos === -1) continue;
-    let lo = 0;
-    let hi = tails.length;
-    while (lo < hi) {
-      const mid = lo + hi >> 1;
-      if (tails[mid] < pos) lo = mid + 1;
-      else hi = mid;
-    }
-    if (lo === tails.length) {
-      tails.push(pos);
-      tailsIdx.push(i);
-    } else {
-      tails[lo] = pos;
-      tailsIdx[lo] = i;
+  if (existingListeners) {
+    for (const eventName of existingListeners.keys()) {
+      const entry = existingListeners.get(eventName);
+      if (!desiredEventNames.has(eventName)) {
+        el.removeEventListener(eventName, entry.handler);
+        existingListeners.delete(eventName);
+      }
     }
-    prev[i] = lo > 0 ? tailsIdx[lo - 1] : -1;
+    if (existingListeners.size === 0) elementListeners.delete(el);
   }
-  let k = tailsIdx.length ? tailsIdx[tailsIdx.length - 1] : -1;
-  while (k !== -1) {
-    keepSet.add(k);
-    k = prev[k];
+  if (updateChildren) {
+    const children = vnode.children || props.children;
+    updateElementChildren(el, children);
   }
-  const tLIS = (typeof performance !== "undefined" && performance.now ? performance.now() : Date.now()) - tailsStart;
-  if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
-    try {
-      const prev2 = globalThis.__ASKR_BULK_DIAG;
-      globalThis.__ASKR_BULK_DIAG = {
-        phase: "keyed-fallback-lis",
-        positionsFound: positions.filter((p) => p !== -1).length,
-        keepCount: keepSet.size,
-        tLIS,
-        previousDecision: prev2?.decision
-      };
-    } catch (e) {
-      void e;
-    }
+}
+function updateElementChildren(el, children) {
+  if (!children) {
+    el.textContent = "";
+    return;
   }
-  let anchor = parent.firstChild;
-  for (let i = 0; i < keyedVnodes.length; i++) {
-    const { key, vnode } = keyedVnodes[i];
-    const el = oldKeyMap?.get(key);
-    if (el && el.parentElement === parent) {
-      if (keepSet.has(i)) {
-        if (anchor === el) {
-          anchor = el.nextSibling;
-        }
-        updateElementFromVnode(el, vnode);
-        newKeyMap.set(key, el);
-      } else {
-        parent.insertBefore(el, anchor);
-        updateElementFromVnode(el, vnode);
-        newKeyMap.set(key, el);
-        anchor = el.nextSibling;
-      }
+  if (!Array.isArray(children) && (typeof children === "string" || typeof children === "number")) {
+    if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
+      el.firstChild.data = String(children);
     } else {
-      const newEl = createDOMNode(vnode);
-      if (newEl instanceof Element) {
-        parent.insertBefore(newEl, anchor);
-        newKeyMap.set(key, newEl);
-        anchor = newEl.nextSibling;
-      }
+      el.textContent = String(children);
     }
+    return;
   }
-  for (const vnode of unkeyedVnodes) {
-    const newEl = createDOMNode(vnode);
-    if (newEl) {
-      parent.appendChild(newEl);
-    }
+  if (Array.isArray(children)) {
+    updateUnkeyedChildren(el, children);
+    return;
   }
-  return newKeyMap;
+  el.textContent = "";
+  const dom = createDOMNode(children);
+  if (dom) el.appendChild(dom);
 }
-function performBulkKeyedTextReplace(parent, keyedVnodes, oldKeyMap) {
-  const total = keyedVnodes.length;
-  const finalNodes = [];
-  let reused = 0;
-  let created = 0;
-  const t0 = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
-  for (let i = 0; i < total; i++) {
-    const { key, vnode } = keyedVnodes[i];
-    const el = oldKeyMap?.get(key);
-    if (el && _isDOMElement(vnode) && typeof vnode.type === "string") {
-      const children = vnode.children || vnode.props?.children;
-      if (typeof children === "string" || typeof children === "number") {
-        if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
-          el.firstChild.data = String(children);
-        } else {
-          el.textContent = String(children);
-        }
-      } else if (Array.isArray(children) && children.length === 1 && (typeof children[0] === "string" || typeof children[0] === "number")) {
-        if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
-          el.firstChild.data = String(children[0]);
+function updateUnkeyedChildren(parent, newChildren) {
+  const existing = Array.from(parent.children);
+  if (existing.length === 0 && parent.childNodes.length > 0) {
+    parent.textContent = "";
+  }
+  const max = Math.max(existing.length, newChildren.length);
+  for (let i = 0; i < max; i++) {
+    const current = existing[i];
+    const next = newChildren[i];
+    if (next === void 0 && current) {
+      cleanupInstanceIfPresent(current);
+      current.remove();
+      continue;
+    }
+    if (!current && next !== void 0) {
+      const dom = createDOMNode(next);
+      if (dom) parent.appendChild(dom);
+      continue;
+    }
+    if (!current || next === void 0) continue;
+    if (typeof next === "string" || typeof next === "number") {
+      current.textContent = String(next);
+    } else if (_isDOMElement(next)) {
+      if (typeof next.type === "string") {
+        if (current.tagName.toLowerCase() === next.type.toLowerCase()) {
+          updateElementFromVnode(current, next);
         } else {
-          el.textContent = String(children[0]);
+          const dom = createDOMNode(next);
+          if (dom) {
+            if (current instanceof Element) removeAllListeners(current);
+            cleanupInstanceIfPresent(current);
+            parent.replaceChild(dom, current);
+          }
         }
       } else {
-        updateElementFromVnode(el, vnode);
+        const dom = createDOMNode(next);
+        if (dom) {
+          if (current instanceof Element) removeAllListeners(current);
+          cleanupInstanceIfPresent(current);
+          parent.replaceChild(dom, current);
+        }
       }
-      finalNodes.push(el);
-      reused++;
     } else {
-      const dom = createDOMNode(vnode);
+      const dom = createDOMNode(next);
       if (dom) {
-        finalNodes.push(dom);
-        created++;
-      }
-    }
-  }
-  try {
-    const toRemove = Array.from(parent.childNodes).filter(
-      (n) => !finalNodes.includes(n)
-    );
-    for (const n of toRemove) cleanupInstanceIfPresent(n);
-  } catch (e) {
-    void e;
-  }
-  const existingChildren = Array.from(parent.children);
-  const listenerSnapshots = new Array(existingChildren.length).fill(void 0);
-  try {
-    for (let i = 0; i < existingChildren.length; i++) {
-      const ch = existingChildren[i];
-      if (ch) {
-        const map = elementListeners.get(ch);
-        if (map && map.size > 0) {
-          const clone = /* @__PURE__ */ new Map();
-          for (const [k, v] of map) clone.set(k, v);
-          listenerSnapshots[i] = clone;
-        }
-      }
-    }
-  } catch (e) {
-    void e;
-  }
-  const fragment = document.createDocumentFragment();
-  for (let i = 0; i < finalNodes.length; i++)
-    fragment.appendChild(finalNodes[i]);
-  parent.replaceChildren(fragment);
-  try {
-    for (let i = 0; i < finalNodes.length; i++) {
-      const newNode = finalNodes[i];
-      const snapshot = listenerSnapshots[i];
-      if (snapshot && newNode instanceof Element) {
-        for (const [eventName, entry] of snapshot) {
-          const existing = elementListeners.get(newNode)?.get(eventName);
-          if (existing && existing.original === entry.original) continue;
-          newNode.addEventListener(eventName, entry.handler);
-          if (!elementListeners.has(newNode))
-            elementListeners.set(newNode, /* @__PURE__ */ new Map());
-          elementListeners.get(newNode).set(eventName, entry);
-        }
+        if (current instanceof Element) removeAllListeners(current);
+        cleanupInstanceIfPresent(current);
+        parent.replaceChild(dom, current);
       }
     }
-  } catch (e) {
-    void e;
-  }
-  try {
-    keyedElements.delete(parent);
-  } catch (e) {
-    void e;
   }
-  const t = typeof performance !== "undefined" && performance.now ? performance.now() - t0 : 0;
-  const stats = {
-    n: total,
-    reused,
-    created,
-    t
-  };
-  return stats;
 }
 function performBulkPositionalKeyedTextUpdate(parent, keyedVnodes) {
   const total = keyedVnodes.length;
@@ -2174,6 +1203,18 @@ function performBulkPositionalKeyedTextUpdate(parent, keyedVnodes) {
       const vnodeType = vnode.type;
       if (ch.tagName.toLowerCase() === vnodeType.toLowerCase()) {
         const children = vnode.children || vnode.props?.children;
+        try {
+          if (process.env.ASKR_FASTPATH_DEBUG === "1" || process.env.ASKR_FASTPATH_DEBUG === "true") {
+            logger.warn("[Askr][FASTPATH] positional idx", i, {
+              chTag: ch.tagName.toLowerCase(),
+              vnodeType,
+              chChildNodes: ch.childNodes.length,
+              childrenType: Array.isArray(children) ? "array" : typeof children
+            });
+          }
+        } catch (e) {
+          void e;
+        }
         if (typeof children === "string" || typeof children === "number") {
           if (ch.childNodes.length === 1 && ch.firstChild?.nodeType === 3) {
             ch.firstChild.data = String(children);
@@ -2197,6 +1238,27 @@ function performBulkPositionalKeyedTextUpdate(parent, keyedVnodes) {
         }
         reused++;
         continue;
+      } else {
+        try {
+          if (process.env.ASKR_FASTPATH_DEBUG === "1" || process.env.ASKR_FASTPATH_DEBUG === "true") {
+            logger.warn("[Askr][FASTPATH] positional tag mismatch", i, {
+              chTag: ch.tagName.toLowerCase(),
+              vnodeType
+            });
+          }
+        } catch (e) {
+          void e;
+        }
+      }
+    } else {
+      try {
+        if (process.env.ASKR_FASTPATH_DEBUG === "1" || process.env.ASKR_FASTPATH_DEBUG === "true") {
+          logger.warn("[Askr][FASTPATH] positional missing or invalid", i, {
+            ch: !!ch
+          });
+        }
+      } catch (e) {
+        void e;
       }
     }
     const dom = createDOMNode(vnode);
@@ -2220,12 +1282,99 @@ function performBulkPositionalKeyedTextUpdate(parent, keyedVnodes) {
   } catch (e) {
     void e;
   }
+  const stats = { n: total, reused, updatedKeys, t };
+  try {
+    if (process.env.ASKR_FASTPATH_DEBUG === "1" || process.env.ASKR_FASTPATH_DEBUG === "true") {
+      logger.warn("[Askr][FASTPATH] bulk positional stats", stats);
+    }
+    __ASKR_set("__LAST_FASTPATH_STATS", stats);
+    __ASKR_set("__LAST_FASTPATH_COMMIT_COUNT", 1);
+    __ASKR_incCounter("bulkKeyedPositionalHits");
+  } catch (e) {
+    void e;
+  }
+  return stats;
+}
+function performBulkTextReplace(parent, newChildren) {
+  const t0 = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+  const existing = Array.from(parent.childNodes);
+  const finalNodes = [];
+  let reused = 0;
+  let created = 0;
+  for (let i = 0; i < newChildren.length; i++) {
+    const vnode = newChildren[i];
+    const existingNode = existing[i];
+    if (typeof vnode === "string" || typeof vnode === "number") {
+      const text = String(vnode);
+      if (existingNode && existingNode.nodeType === 3) {
+        existingNode.data = text;
+        finalNodes.push(existingNode);
+        reused++;
+      } else {
+        finalNodes.push(document.createTextNode(text));
+        created++;
+      }
+      continue;
+    }
+    if (typeof vnode === "object" && vnode !== null && "type" in vnode) {
+      const vnodeObj = vnode;
+      if (typeof vnodeObj.type === "string") {
+        const tag = vnodeObj.type;
+        if (existingNode && existingNode.nodeType === 1 && existingNode.tagName.toLowerCase() === tag.toLowerCase()) {
+          updateElementFromVnode(existingNode, vnode);
+          finalNodes.push(existingNode);
+          reused++;
+          continue;
+        }
+      }
+      const dom = createDOMNode(vnode);
+      if (dom) {
+        finalNodes.push(dom);
+        created++;
+        continue;
+      }
+    }
+  }
+  const tBuild = (typeof performance !== "undefined" && performance.now ? performance.now() : Date.now()) - t0;
+  try {
+    const toRemove = Array.from(parent.childNodes).filter(
+      (n) => !finalNodes.includes(n)
+    );
+    for (const n of toRemove) {
+      if (n instanceof Element) removeAllListeners(n);
+      cleanupInstanceIfPresent(n);
+    }
+  } catch (e) {
+    void e;
+  }
+  const fragStart = Date.now();
+  const fragment = document.createDocumentFragment();
+  for (let i = 0; i < finalNodes.length; i++)
+    fragment.appendChild(finalNodes[i]);
+  try {
+    __ASKR_incCounter("__DOM_REPLACE_COUNT");
+    __ASKR_set("__LAST_DOM_REPLACE_STACK_DOM", new Error().stack);
+  } catch (e) {
+    void e;
+  }
+  parent.replaceChildren(fragment);
+  const tCommit = Date.now() - fragStart;
+  keyedElements.delete(parent);
   const stats = {
-    n: total,
+    n: newChildren.length,
     reused,
-    updatedKeys,
-    t
+    created,
+    tBuild,
+    tCommit
   };
+  try {
+    __ASKR_set("__LAST_BULK_TEXT_FASTPATH_STATS", stats);
+    __ASKR_set("__LAST_FASTPATH_STATS", stats);
+    __ASKR_set("__LAST_FASTPATH_COMMIT_COUNT", 1);
+    __ASKR_incCounter("bulkTextFastpathHits");
+  } catch (e) {
+    void e;
+  }
   return stats;
 }
 function isBulkTextFastPathEligible(parent, newChildren) {
@@ -2235,12 +1384,12 @@ function isBulkTextFastPathEligible(parent, newChildren) {
   if (total < threshold) {
     if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
       try {
-        globalThis.__ASKR_BULK_DIAG = {
+        __ASKR_set("__BULK_DIAG", {
           phase: "bulk-unkeyed-eligible",
           reason: "too-small",
           total,
           threshold
-        };
+        });
       } catch (e) {
         void e;
       }
@@ -2259,11 +1408,11 @@ function isBulkTextFastPathEligible(parent, newChildren) {
       if (typeof dv.type === "function") {
         if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
           try {
-            globalThis.__ASKR_BULK_DIAG = {
+            __ASKR_set("__BULK_DIAG", {
               phase: "bulk-unkeyed-eligible",
               reason: "component-child",
               index: i
-            };
+            });
           } catch (e) {
             void e;
           }
@@ -2292,438 +1441,806 @@ function isBulkTextFastPathEligible(parent, newChildren) {
   const eligible = fraction >= requiredFraction && parent.childNodes.length >= total;
   if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
     try {
-      globalThis.__ASKR_BULK_DIAG = {
+      __ASKR_set("__BULK_DIAG", {
         phase: "bulk-unkeyed-eligible",
         total,
         simple,
         fraction,
         requiredFraction,
         eligible
-      };
+      });
     } catch (e) {
       void e;
     }
   }
   return eligible;
 }
-function performBulkTextReplace(parent, newChildren) {
-  const t0 = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
-  const existing = Array.from(parent.childNodes);
-  const finalNodes = [];
-  let reused = 0;
-  let created = 0;
-  for (let i = 0; i < newChildren.length; i++) {
-    const vnode = newChildren[i];
-    const existingNode = existing[i];
-    if (typeof vnode === "string" || typeof vnode === "number") {
-      const text = String(vnode);
-      if (existingNode && existingNode.nodeType === 3) {
-        existingNode.data = text;
-        finalNodes.push(existingNode);
-        reused++;
-      } else {
-        finalNodes.push(document.createTextNode(text));
-        created++;
-      }
-      continue;
+var IS_DOM_AVAILABLE;
+var init_dom = __esm({
+  "src/renderer/dom.ts"() {
+    "use strict";
+    init_scheduler();
+    init_logger();
+    init_jsx_runtime();
+    init_context();
+    init_component();
+    init_cleanup();
+    init_diag();
+    init_types();
+    init_keyed();
+    IS_DOM_AVAILABLE = typeof document !== "undefined";
+  }
+});
+
+// src/renderer/fastpath.ts
+function applyRendererFastPath(parent, keyedVnodes, oldKeyMap, unkeyedVnodes) {
+  if (typeof document === "undefined") return null;
+  const totalKeyed = keyedVnodes.length;
+  if (totalKeyed === 0 && (!unkeyedVnodes || unkeyedVnodes.length === 0))
+    return null;
+  if (!isSchedulerExecuting()) {
+    logger.warn(
+      "[Askr][FASTPATH][DEV] Fast-path reconciliation invoked outside scheduler execution"
+    );
+  }
+  let parentChildrenArr;
+  let localOldKeyMap;
+  if (totalKeyed <= 20) {
+    try {
+      const pc = parent.children;
+      parentChildrenArr = new Array(pc.length);
+      for (let i = 0; i < pc.length; i++)
+        parentChildrenArr[i] = pc[i];
+    } catch (e) {
+      parentChildrenArr = void 0;
+      void e;
     }
-    if (typeof vnode === "object" && vnode !== null && "type" in vnode) {
-      if (typeof vnode.type === "string") {
-        const vtype = vnode.type;
-        if (existingNode && existingNode.nodeType === 1 && existingNode.tagName.toLowerCase() === vtype.toLowerCase()) {
-          const el = existingNode;
-          const children = vnode.children || vnode.props?.children;
-          if (typeof children === "string" || typeof children === "number") {
-            if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
-              el.firstChild.data = String(children);
-            } else {
-              el.textContent = String(children);
-            }
-          } else if (Array.isArray(children) && children.length === 1 && (typeof children[0] === "string" || typeof children[0] === "number")) {
-            if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
-              el.firstChild.data = String(children[0]);
-            } else {
-              el.textContent = String(children[0]);
-            }
-          } else {
-            updateElementFromVnode(el, vnode);
-          }
-          finalNodes.push(el);
-          reused++;
-          continue;
-        }
-        const dom2 = createDOMNode(vnode);
-        if (dom2) {
-          finalNodes.push(dom2);
-          created++;
+  } else {
+    localOldKeyMap = /* @__PURE__ */ new Map();
+    try {
+      const parentChildren = Array.from(parent.children);
+      for (let i = 0; i < parentChildren.length; i++) {
+        const ch = parentChildren[i];
+        const k = ch.getAttribute("data-key");
+        if (k !== null) {
+          localOldKeyMap.set(k, ch);
+          const n = Number(k);
+          if (!Number.isNaN(n)) localOldKeyMap.set(n, ch);
         }
-        continue;
       }
+    } catch (e) {
+      localOldKeyMap = void 0;
+      void e;
     }
-    const dom = createDOMNode(vnode);
-    if (dom) {
-      finalNodes.push(dom);
-      created++;
-    }
-  }
-  const tBuild = typeof performance !== "undefined" && performance.now ? performance.now() - t0 : 0;
-  try {
-    const toRemove = Array.from(parent.childNodes).filter(
-      (n) => !finalNodes.includes(n)
-    );
-    for (const n of toRemove) cleanupInstanceIfPresent(n);
-  } catch (e) {
-    void e;
   }
-  const fragStart = Date.now();
-  const fragment = document.createDocumentFragment();
-  for (let i = 0; i < finalNodes.length; i++)
-    fragment.appendChild(finalNodes[i]);
-  parent.replaceChildren(fragment);
-  const tCommit = Date.now() - fragStart;
-  keyedElements.delete(parent);
-  const stats = {
-    n: newChildren.length,
-    reused,
-    created,
-    tBuild,
-    tCommit
-  };
-  return stats;
-}
-function updateElementFromVnode(el, vnode, updateChildren = true) {
-  if (!_isDOMElement(vnode)) {
-    return;
-  }
-  const props = vnode.props || {};
-  if (vnode.key !== void 0) {
-    el.setAttribute("data-key", String(vnode.key));
-  }
-  const existingListeners = elementListeners.get(el);
-  const desiredEventNames = /* @__PURE__ */ new Set();
-  for (const key in props) {
-    const value = props[key];
-    if (key === "children" || key === "key") continue;
-    if (value === void 0 || value === null || value === false) {
-      if (key === "class" || key === "className") {
-        el.className = "";
-      } else if (key.startsWith("on") && key.length > 2) {
-        const eventName = key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();
-        if (existingListeners && existingListeners.has(eventName)) {
-          const entry = existingListeners.get(eventName);
-          el.removeEventListener(eventName, entry.handler);
-          existingListeners.delete(eventName);
+  const finalNodes = [];
+  let mapLookups = 0;
+  let createdNodes = 0;
+  let reusedCount = 0;
+  for (let i = 0; i < keyedVnodes.length; i++) {
+    const { key, vnode } = keyedVnodes[i];
+    mapLookups++;
+    let el;
+    if (totalKeyed <= 20 && parentChildrenArr) {
+      const ks = String(key);
+      for (let j = 0; j < parentChildrenArr.length; j++) {
+        const ch = parentChildrenArr[j];
+        const k = ch.getAttribute("data-key");
+        if (k !== null && (k === ks || Number(k) === key)) {
+          el = ch;
+          break;
         }
-        continue;
-      } else {
-        el.removeAttribute(key);
       }
-      continue;
+      if (!el) el = oldKeyMap?.get(key);
+    } else {
+      el = localOldKeyMap?.get(key) ?? oldKeyMap?.get(key);
     }
-    if (key === "class" || key === "className") {
-      el.className = String(value);
-    } else if (key === "value" || key === "checked") {
-      el[key] = value;
-    } else if (key.startsWith("on") && key.length > 2) {
-      const eventName = key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();
-      desiredEventNames.add(eventName);
-      const existing = existingListeners?.get(eventName);
-      if (existing && existing.original === value) {
-        continue;
-      }
-      if (existing) {
-        el.removeEventListener(eventName, existing.handler);
-      }
-      const wrappedHandler = (event) => {
-        globalScheduler.setInHandler(true);
-        try {
-          value(event);
-        } catch (error) {
-          logger.error("[Askr] Event handler error:", error);
-        } finally {
-          globalScheduler.setInHandler(false);
-        }
-      };
-      el.addEventListener(eventName, wrappedHandler);
-      if (!elementListeners.has(el)) {
-        elementListeners.set(el, /* @__PURE__ */ new Map());
-      }
-      elementListeners.get(el).set(eventName, {
-        handler: wrappedHandler,
-        original: value
-      });
+    if (el) {
+      finalNodes.push(el);
+      reusedCount++;
     } else {
-      el.setAttribute(key, String(value));
+      const newEl = createDOMNode(vnode);
+      if (newEl) {
+        finalNodes.push(newEl);
+        createdNodes++;
+      }
     }
   }
-  if (existingListeners) {
-    for (const eventName of existingListeners.keys()) {
-      const entry = existingListeners.get(eventName);
-      if (!desiredEventNames.has(eventName)) {
-        el.removeEventListener(eventName, entry.handler);
-        existingListeners.delete(eventName);
+  if (unkeyedVnodes && unkeyedVnodes.length) {
+    for (const vnode of unkeyedVnodes) {
+      const newEl = createDOMNode(vnode);
+      if (newEl) {
+        finalNodes.push(newEl);
+        createdNodes++;
       }
     }
-    if (existingListeners.size === 0) elementListeners.delete(el);
   }
-  if (updateChildren) {
-    const children = vnode.children || props.children;
-    updateElementChildren(el, children);
+  try {
+    const tFragmentStart = Date.now();
+    const fragment = document.createDocumentFragment();
+    let fragmentAppendCount = 0;
+    for (let i = 0; i < finalNodes.length; i++) {
+      fragment.appendChild(finalNodes[i]);
+      fragmentAppendCount++;
+    }
+    try {
+      const existing = Array.from(parent.childNodes);
+      const toRemove = existing.filter((n) => !finalNodes.includes(n));
+      for (const n of toRemove) {
+        if (n instanceof Element) removeAllListeners(n);
+        cleanupInstanceIfPresent(n);
+      }
+    } catch (e) {
+      void e;
+    }
+    try {
+      __ASKR_incCounter("__DOM_REPLACE_COUNT");
+      __ASKR_set("__LAST_DOM_REPLACE_STACK_FASTPATH", new Error().stack);
+    } catch (e) {
+      void e;
+    }
+    parent.replaceChildren(fragment);
+    try {
+      __ASKR_set("__LAST_FASTPATH_COMMIT_COUNT", 1);
+    } catch (e) {
+      void e;
+    }
+    try {
+      if (isBulkCommitActive2()) markFastPathApplied(parent);
+    } catch (e) {
+      void e;
+    }
+    const newKeyMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < keyedVnodes.length; i++) {
+      const key = keyedVnodes[i].key;
+      const node = finalNodes[i];
+      if (node instanceof Element) newKeyMap.set(key, node);
+    }
+    try {
+      const stats = {
+        n: totalKeyed,
+        moves: 0,
+        lisLen: 0,
+        t_lookup: 0,
+        t_fragment: Date.now() - tFragmentStart,
+        t_commit: 0,
+        t_bookkeeping: 0,
+        fragmentAppendCount,
+        mapLookups,
+        createdNodes,
+        reusedCount
+      };
+      if (typeof globalThis !== "undefined") {
+        __ASKR_set("__LAST_FASTPATH_STATS", stats);
+        __ASKR_set("__LAST_FASTPATH_REUSED", reusedCount > 0);
+        __ASKR_incCounter("fastpathHistoryPush");
+      }
+      if (process.env.ASKR_FASTPATH_DEBUG === "1" || process.env.ASKR_FASTPATH_DEBUG === "true") {
+        logger.warn(
+          "[Askr][FASTPATH]",
+          JSON.stringify({ n: totalKeyed, createdNodes, reusedCount })
+        );
+      }
+    } catch (e) {
+      void e;
+    }
+    try {
+      _reconcilerRecordedParents.add(parent);
+    } catch (e) {
+      void e;
+    }
+    return newKeyMap;
+  } catch (e) {
+    void e;
+    return null;
   }
 }
-function updateElementChildren(el, children) {
-  if (!children) {
-    el.textContent = "";
-    return;
+var init_fastpath = __esm({
+  "src/renderer/fastpath.ts"() {
+    "use strict";
+    init_dom();
+    init_keyed();
+    init_logger();
+    init_cleanup();
+    init_diag();
+    init_scheduler();
+    init_fastlane_shared();
   }
-  if (!Array.isArray(children) && (typeof children === "string" || typeof children === "number")) {
-    if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
-      el.firstChild.data = String(children);
+});
+
+// src/renderer/reconcile.ts
+function reconcileKeyedChildren(parent, newChildren, oldKeyMap) {
+  const newKeyMap = /* @__PURE__ */ new Map();
+  const keyedVnodes = [];
+  const unkeyedVnodes = [];
+  for (let i = 0; i < newChildren.length; i++) {
+    const child = newChildren[i];
+    if (typeof child === "object" && child !== null && "type" in child) {
+      const childObj = child;
+      const rawKey = childObj.key ?? childObj.props?.key;
+      if (rawKey !== void 0) {
+        const key = typeof rawKey === "symbol" ? String(rawKey) : rawKey;
+        keyedVnodes.push({ key, vnode: child });
+      } else {
+        unkeyedVnodes.push(child);
+      }
     } else {
-      el.textContent = String(children);
+      unkeyedVnodes.push(child);
     }
-    return;
   }
-  if (Array.isArray(children)) {
-    updateUnkeyedChildren(el, children);
-    return;
-  }
-  el.textContent = "";
-  const dom = createDOMNode(children);
-  if (dom) el.appendChild(dom);
-}
-function updateUnkeyedChildren(parent, newChildren) {
-  const existing = Array.from(parent.children);
-  if (existing.length === 0 && parent.childNodes.length > 0) {
-    parent.textContent = "";
+  try {
+    const decision = isKeyedReorderFastPathEligible(
+      parent,
+      newChildren,
+      oldKeyMap
+    );
+    if (decision.useFastPath && keyedVnodes.length >= 128 || // If we're executing inside a runtime bulk commit (fastlane), prefer the
+    // renderer fast-path to ensure the single-commit invariant is preserved.
+    isBulkCommitActive2()) {
+      try {
+        const map = applyRendererFastPath(
+          parent,
+          keyedVnodes,
+          oldKeyMap,
+          unkeyedVnodes
+        );
+        if (map) {
+          try {
+            keyedElements.set(parent, map);
+          } catch (e) {
+            void e;
+          }
+          return map;
+        }
+      } catch (e) {
+        void e;
+      }
+    }
+    try {
+      const total = keyedVnodes.length;
+      if (total >= 10) {
+        let matchCount = 0;
+        try {
+          for (let i = 0; i < total; i++) {
+            const vnode = keyedVnodes[i].vnode;
+            if (!vnode || typeof vnode !== "object" || typeof vnode.type !== "string")
+              continue;
+            const el = parent.children[i];
+            if (!el) continue;
+            if (el.tagName.toLowerCase() === String(vnode.type).toLowerCase())
+              matchCount++;
+          }
+        } catch (e) {
+          void e;
+        }
+        if (matchCount / total >= 0.9) {
+          let hasPropChanges = false;
+          try {
+            for (let i = 0; i < total; i++) {
+              const vnode = keyedVnodes[i].vnode;
+              const el = parent.children[i];
+              if (!el || !vnode || typeof vnode !== "object") continue;
+              const props = vnode.props || {};
+              for (const k of Object.keys(props)) {
+                if (k === "children" || k === "key") continue;
+                if (k.startsWith("on") && k.length > 2) continue;
+                if (k.startsWith("data-")) continue;
+                const v = props[k];
+                try {
+                  if (k === "class" || k === "className") {
+                    if (el.className !== String(v)) {
+                      hasPropChanges = true;
+                      break;
+                    }
+                  } else if (k === "value" || k === "checked") {
+                    if (el[k] !== v) {
+                      hasPropChanges = true;
+                      break;
+                    }
+                  } else {
+                    const attr = el.getAttribute(k);
+                    if (v === void 0 || v === null || v === false) {
+                      if (attr !== null) {
+                        hasPropChanges = true;
+                        break;
+                      }
+                    } else if (String(v) !== attr) {
+                      hasPropChanges = true;
+                      break;
+                    }
+                  }
+                } catch (e) {
+                  hasPropChanges = true;
+                  void e;
+                  break;
+                }
+              }
+              if (hasPropChanges) break;
+            }
+          } catch (e) {
+            void e;
+          }
+          if (hasPropChanges) {
+          } else {
+            try {
+              const stats = performBulkPositionalKeyedTextUpdate(
+                parent,
+                keyedVnodes
+              );
+              if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+                try {
+                  __ASKR_set("__LAST_FASTPATH_STATS", stats);
+                  __ASKR_set("__LAST_FASTPATH_COMMIT_COUNT", 1);
+                  __ASKR_incCounter("bulkKeyedPositionalHits");
+                } catch (e) {
+                  void e;
+                }
+              }
+              try {
+                const map = /* @__PURE__ */ new Map();
+                const children = Array.from(parent.children);
+                for (let i = 0; i < children.length; i++) {
+                  const el = children[i];
+                  const k = el.getAttribute("data-key");
+                  if (k !== null) {
+                    map.set(k, el);
+                    const n = Number(k);
+                    if (!Number.isNaN(n)) map.set(n, el);
+                  }
+                }
+                keyedElements.set(parent, map);
+              } catch (e) {
+                void e;
+              }
+              return keyedElements.get(parent);
+            } catch (e) {
+              void e;
+            }
+          }
+        }
+      }
+    } catch (e) {
+      void e;
+    }
+  } catch (e) {
+    void e;
   }
-  const max = Math.max(existing.length, newChildren.length);
-  for (let i = 0; i < max; i++) {
-    const current = existing[i];
-    const next = newChildren[i];
-    if (next === void 0 && current) {
-      cleanupInstanceIfPresent(current);
-      current.remove();
-      continue;
+  const finalNodes = [];
+  const usedOldEls = /* @__PURE__ */ new WeakSet();
+  const resolveOldElOnce = (k) => {
+    if (!oldKeyMap) return void 0;
+    const direct = oldKeyMap.get(k);
+    if (direct && !usedOldEls.has(direct)) {
+      usedOldEls.add(direct);
+      return direct;
+    }
+    const s = String(k);
+    const byString = oldKeyMap.get(s);
+    if (byString && !usedOldEls.has(byString)) {
+      usedOldEls.add(byString);
+      return byString;
+    }
+    const n = Number(String(k));
+    if (!Number.isNaN(n)) {
+      const byNum = oldKeyMap.get(n);
+      if (byNum && !usedOldEls.has(byNum)) {
+        usedOldEls.add(byNum);
+        return byNum;
+      }
     }
-    if (!current && next !== void 0) {
-      const dom = createDOMNode(next);
-      if (dom) parent.appendChild(dom);
-      continue;
+    try {
+      const children = Array.from(parent.children);
+      for (const ch of children) {
+        if (usedOldEls.has(ch)) continue;
+        const attr = ch.getAttribute("data-key");
+        if (attr === s) {
+          usedOldEls.add(ch);
+          return ch;
+        }
+        const numAttr = Number(attr);
+        if (!Number.isNaN(numAttr) && numAttr === k) {
+          usedOldEls.add(ch);
+          return ch;
+        }
+      }
+    } catch (e) {
+      void e;
     }
-    if (!current || next === void 0) continue;
-    if (typeof next === "string" || typeof next === "number") {
-      current.textContent = String(next);
-    } else if (_isDOMElement(next)) {
-      if (typeof next.type === "string") {
-        if (current.tagName.toLowerCase() === next.type.toLowerCase()) {
-          updateElementFromVnode(current, next);
-        } else {
-          const dom = createDOMNode(next);
-          if (dom) {
-            cleanupInstanceIfPresent(current);
-            parent.replaceChild(dom, current);
-          }
+    return void 0;
+  };
+  for (let i = 0; i < newChildren.length; i++) {
+    const child = newChildren[i];
+    if (typeof child === "object" && child !== null && "type" in child) {
+      const childObj = child;
+      const rawKey = childObj.key ?? childObj.props?.key;
+      if (rawKey !== void 0) {
+        const key = typeof rawKey === "symbol" ? String(rawKey) : rawKey;
+        const el = resolveOldElOnce(key);
+        if (el && el.parentElement === parent) {
+          updateElementFromVnode(el, child);
+          finalNodes.push(el);
+          newKeyMap.set(key, el);
+          continue;
         }
-      } else {
-        const dom = createDOMNode(next);
-        if (dom) {
-          cleanupInstanceIfPresent(current);
-          parent.replaceChild(dom, current);
+        const dom2 = createDOMNode(child);
+        if (dom2) {
+          finalNodes.push(dom2);
+          if (dom2 instanceof Element) newKeyMap.set(key, dom2);
         }
+        continue;
       }
-    } else {
-      const dom = createDOMNode(next);
-      if (dom) {
-        cleanupInstanceIfPresent(current);
-        parent.replaceChild(dom, current);
+    }
+    try {
+      const existing = parent.children[i];
+      if (existing && (typeof child === "string" || typeof child === "number") && existing.nodeType === 1) {
+        existing.textContent = String(child);
+        finalNodes.push(existing);
+        usedOldEls.add(existing);
+        continue;
+      }
+      if (existing && typeof child === "object" && child !== null && "type" in child && (existing.getAttribute("data-key") === null || existing.getAttribute("data-key") === void 0) && typeof child.type === "string" && existing.tagName.toLowerCase() === String(child.type).toLowerCase()) {
+        updateElementFromVnode(existing, child);
+        finalNodes.push(existing);
+        usedOldEls.add(existing);
+        continue;
+      }
+      try {
+        const avail = Array.from(parent.children).find(
+          (ch) => !usedOldEls.has(ch) && ch.getAttribute("data-key") === null
+        );
+        if (avail) {
+          if (typeof child === "string" || typeof child === "number") {
+            avail.textContent = String(child);
+          } else if (typeof child === "object" && child !== null && "type" in child && typeof child.type === "string" && avail.tagName.toLowerCase() === String(child.type).toLowerCase()) {
+            updateElementFromVnode(avail, child);
+          } else {
+            const dom2 = createDOMNode(child);
+            if (dom2) {
+              finalNodes.push(dom2);
+              continue;
+            }
+          }
+          usedOldEls.add(avail);
+          finalNodes.push(avail);
+          continue;
+        }
+      } catch (e) {
+        void e;
       }
+    } catch (e) {
+      void e;
     }
+    const dom = createDOMNode(child);
+    if (dom) finalNodes.push(dom);
   }
-}
-function createDOMNode(node) {
-  if (typeof node === "string") {
-    return document.createTextNode(node);
+  if (typeof document === "undefined") return newKeyMap;
+  const fragment = document.createDocumentFragment();
+  for (let i = 0; i < finalNodes.length; i++)
+    fragment.appendChild(finalNodes[i]);
+  try {
+    const existing = Array.from(parent.childNodes);
+    for (const n of existing) {
+      if (n instanceof Element) removeAllListeners(n);
+      cleanupInstanceIfPresent(n);
+    }
+  } catch (e) {
+    void e;
   }
-  if (typeof node === "number") {
-    return document.createTextNode(String(node));
+  try {
+    __ASKR_incCounter("__DOM_REPLACE_COUNT");
+    __ASKR_set("__LAST_DOM_REPLACE_STACK_RECONCILE", new Error().stack);
+  } catch (e) {
+    void e;
   }
-  if (!node) {
-    return null;
+  parent.replaceChildren(fragment);
+  keyedElements.delete(parent);
+  return newKeyMap;
+}
+var init_reconcile = __esm({
+  "src/renderer/reconcile.ts"() {
+    "use strict";
+    init_dom();
+    init_keyed();
+    init_cleanup();
+    init_fastlane_shared();
+    init_diag();
+    init_fastpath();
   }
-  if (Array.isArray(node)) {
-    const fragment = document.createDocumentFragment();
-    for (let i = 0; i < node.length; i++) {
-      const dom = createDOMNode(node[i]);
-      if (dom) fragment.appendChild(dom);
+});
+
+// src/renderer/evaluate.ts
+function evaluate(node, target, context) {
+  if (!target) return;
+  if (typeof document === "undefined") {
+    if (process.env.NODE_ENV !== "production") {
+      try {
+        console.warn("[Askr] evaluate() called in non-DOM environment; no-op.");
+      } catch (e) {
+        void e;
+      }
     }
-    return fragment;
+    return;
   }
-  if (typeof node === "object" && node !== null && "type" in node) {
-    const type = node.type;
-    const props = node.props || {};
-    if (typeof type === "string") {
-      const el = document.createElement(type);
-      for (const key in props) {
-        const value = props[key];
-        if (key === "children" || key === "key") continue;
-        if (value === void 0 || value === null || value === false) continue;
-        if (key.startsWith("on") && key.length > 2) {
-          const eventName = key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();
-          const wrappedHandler = (event) => {
-            globalScheduler.setInHandler(true);
-            try {
-              value(event);
-            } catch (error) {
-              logger.error("[Askr] Event handler error:", error);
-            } finally {
-              globalScheduler.setInHandler(false);
-              const state = globalScheduler.getState();
-              if ((state.queueLength ?? 0) > 0 && !state.running) {
-                queueMicrotask(() => {
+  if (context && domRanges.has(context)) {
+    const range = domRanges.get(context);
+    let current = range.start.nextSibling;
+    while (current && current !== range.end) {
+      const next = current.nextSibling;
+      current.remove();
+      current = next;
+    }
+    const dom = createDOMNode(node);
+    if (dom) {
+      target.insertBefore(dom, range.end);
+    }
+  } else if (context) {
+    const start = document.createComment("component-start");
+    const end = document.createComment("component-end");
+    target.appendChild(start);
+    target.appendChild(end);
+    domRanges.set(context, { start, end });
+    const dom = createDOMNode(node);
+    if (dom) {
+      target.insertBefore(dom, end);
+    }
+  } else {
+    const vnode = node;
+    const firstChild = target.children[0];
+    if (firstChild && _isDOMElement(vnode) && typeof vnode.type === "string" && firstChild.tagName.toLowerCase() === vnode.type.toLowerCase()) {
+      const vnodeChildren = vnode.children || vnode.props?.children;
+      let isSimpleTextVNode = false;
+      let textContent;
+      if (!Array.isArray(vnodeChildren)) {
+        if (typeof vnodeChildren === "string" || typeof vnodeChildren === "number") {
+          isSimpleTextVNode = true;
+          textContent = String(vnodeChildren);
+        }
+      } else if (vnodeChildren.length === 1) {
+        const child = vnodeChildren[0];
+        if (typeof child === "string" || typeof child === "number") {
+          isSimpleTextVNode = true;
+          textContent = String(child);
+        }
+      }
+      if (isSimpleTextVNode && firstChild.childNodes.length === 1 && firstChild.firstChild?.nodeType === 3) {
+        firstChild.firstChild.data = textContent;
+      } else {
+        if (vnodeChildren) {
+          if (Array.isArray(vnodeChildren)) {
+            const hasKeys = vnodeChildren.some(
+              (child) => typeof child === "object" && child !== null && "key" in child
+            );
+            if (hasKeys) {
+              let oldKeyMap = keyedElements.get(firstChild);
+              if (!oldKeyMap) {
+                oldKeyMap = /* @__PURE__ */ new Map();
+                try {
+                  const children = Array.from(firstChild.children);
+                  for (let i = 0; i < children.length; i++) {
+                    const ch = children[i];
+                    const k = ch.getAttribute("data-key");
+                    if (k !== null) {
+                      oldKeyMap.set(k, ch);
+                      const n = Number(k);
+                      if (!Number.isNaN(n)) oldKeyMap.set(n, ch);
+                    }
+                  }
+                  if (oldKeyMap.size > 0)
+                    keyedElements.set(firstChild, oldKeyMap);
+                } catch (e) {
+                  void e;
+                }
+              }
+              try {
+                if (process.env.ASKR_FORCE_BULK_POSREUSE === "1") {
+                  try {
+                    const keyedVnodes = [];
+                    for (let i = 0; i < vnodeChildren.length; i++) {
+                      const c = vnodeChildren[i];
+                      if (_isDOMElement(c) && c.key !== void 0) {
+                        keyedVnodes.push({
+                          key: c.key,
+                          vnode: c
+                        });
+                      }
+                    }
+                    if (keyedVnodes.length > 0 && keyedVnodes.length === vnodeChildren.length) {
+                      if (process.env.ASKR_FASTPATH_DEBUG === "1" || process.env.ASKR_FASTPATH_DEBUG === "true") {
+                        logger.warn(
+                          "[Askr][FASTPATH] forced positional bulk keyed reuse (evaluate-level)"
+                        );
+                      }
+                      const stats = performBulkPositionalKeyedTextUpdate(
+                        firstChild,
+                        keyedVnodes
+                      );
+                      if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+                        try {
+                          __ASKR_set("__LAST_FASTPATH_STATS", stats);
+                          __ASKR_set("__LAST_FASTPATH_COMMIT_COUNT", 1);
+                          __ASKR_incCounter("bulkKeyedPositionalForced");
+                        } catch (e) {
+                          void e;
+                        }
+                      }
+                      try {
+                        const map = /* @__PURE__ */ new Map();
+                        const children = Array.from(firstChild.children);
+                        for (let i = 0; i < children.length; i++) {
+                          const el = children[i];
+                          const k = el.getAttribute("data-key");
+                          if (k !== null) {
+                            map.set(k, el);
+                            const n = Number(k);
+                            if (!Number.isNaN(n)) map.set(n, el);
+                          }
+                        }
+                        keyedElements.set(firstChild, map);
+                      } catch (e) {
+                        void e;
+                      }
+                    } else {
+                      const newKeyMap = reconcileKeyedChildren(
+                        firstChild,
+                        vnodeChildren,
+                        oldKeyMap
+                      );
+                      keyedElements.set(firstChild, newKeyMap);
+                    }
+                  } catch (err) {
+                    if (process.env.ASKR_FASTPATH_DEBUG === "1" || process.env.ASKR_FASTPATH_DEBUG === "true") {
+                      logger.warn(
+                        "[Askr][FASTPATH] forced bulk path failed, falling back",
+                        err
+                      );
+                    }
+                    const newKeyMap = reconcileKeyedChildren(
+                      firstChild,
+                      vnodeChildren,
+                      oldKeyMap
+                    );
+                    keyedElements.set(firstChild, newKeyMap);
+                  }
+                } else {
+                  const newKeyMap = reconcileKeyedChildren(
+                    firstChild,
+                    vnodeChildren,
+                    oldKeyMap
+                  );
+                  keyedElements.set(firstChild, newKeyMap);
+                }
+              } catch (e) {
+                void e;
+                const newKeyMap = reconcileKeyedChildren(
+                  firstChild,
+                  vnodeChildren,
+                  oldKeyMap
+                );
+                keyedElements.set(firstChild, newKeyMap);
+              }
+            } else {
+              if (isBulkTextFastPathEligible(firstChild, vnodeChildren)) {
+                const stats = performBulkTextReplace(firstChild, vnodeChildren);
+                if (process.env.NODE_ENV !== "production") {
                   try {
-                    if (!globalScheduler.isExecuting()) globalScheduler.flush();
-                  } catch (err) {
-                    setTimeout(() => {
-                      throw err;
-                    });
+                    __ASKR_set("__LAST_BULK_TEXT_FASTPATH_STATS", stats);
+                    __ASKR_incCounter("bulkTextHits");
+                  } catch (e) {
+                    void e;
                   }
-                });
+                }
+              } else {
+                if (process.env.NODE_ENV !== "production") {
+                  try {
+                    __ASKR_incCounter("bulkTextMisses");
+                  } catch (e) {
+                    void e;
+                  }
+                }
+                updateUnkeyedChildren(firstChild, vnodeChildren);
+                keyedElements.delete(firstChild);
               }
             }
-          };
-          el.addEventListener(eventName, wrappedHandler);
-          if (!elementListeners.has(el)) {
-            elementListeners.set(el, /* @__PURE__ */ new Map());
+          } else {
+            firstChild.textContent = "";
+            const dom = createDOMNode(vnodeChildren);
+            if (dom) firstChild.appendChild(dom);
+            keyedElements.delete(firstChild);
           }
-          elementListeners.get(el).set(eventName, {
-            handler: wrappedHandler,
-            original: value
-          });
-        } else if (key === "class" || key === "className") {
-          el.className = String(value);
-        } else if (key === "value" || key === "checked") {
-          el[key] = value;
-          el.setAttribute(key, String(value));
         } else {
-          el.setAttribute(key, String(value));
+          firstChild.textContent = "";
+          keyedElements.delete(firstChild);
         }
       }
-      const vnodeKey = node.key;
-      if (vnodeKey !== void 0) {
-        el.setAttribute("data-key", String(vnodeKey));
-      }
-      const children = props.children || node.children;
-      if (children) {
-        if (Array.isArray(children)) {
-          if (process.env.NODE_ENV !== "production") {
-            let hasElements = false;
-            let hasKeys = false;
-            for (let i = 0; i < children.length; i++) {
-              const item = children[i];
-              if (typeof item === "object" && item !== null && "type" in item) {
-                hasElements = true;
-                const itemProps = item.props || {};
-                if ("key" in itemProps) {
-                  hasKeys = true;
-                  break;
+      updateElementFromVnode(firstChild, vnode, false);
+    } else {
+      target.textContent = "";
+      if (_isDOMElement(vnode) && typeof vnode.type === "string") {
+        const children = vnode.children;
+        if (Array.isArray(children) && children.some(
+          (child) => typeof child === "object" && child !== null && "key" in child
+        )) {
+          const el = document.createElement(vnode.type);
+          target.appendChild(el);
+          const props = vnode.props || {};
+          for (const [key, value] of Object.entries(props)) {
+            if (key === "children" || key === "key") continue;
+            if (value === void 0 || value === null || value === false)
+              continue;
+            if (key.startsWith("on") && key.length > 2) {
+              const eventName = key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();
+              const wrappedHandler = (event) => {
+                globalScheduler.setInHandler(true);
+                try {
+                  value(event);
+                } catch (error) {
+                  logger.error("[Askr] Event handler error:", error);
+                } finally {
+                  globalScheduler.setInHandler(false);
                 }
+              };
+              const options = eventName === "wheel" || eventName === "scroll" || eventName.startsWith("touch") ? { passive: true } : void 0;
+              if (options !== void 0)
+                el.addEventListener(eventName, wrappedHandler, options);
+              else el.addEventListener(eventName, wrappedHandler);
+              if (!elementListeners.has(el)) {
+                elementListeners.set(el, /* @__PURE__ */ new Map());
               }
+              elementListeners.get(el).set(eventName, {
+                handler: wrappedHandler,
+                original: value,
+                options
+              });
+              continue;
             }
-            if (hasElements && !hasKeys) {
-              if (typeof console !== "undefined") {
-                logger.warn(
-                  'Missing keys on dynamic lists. Each child in a list should have a unique "key" prop.'
-                );
-              }
+            if (key === "class" || key === "className") {
+              el.className = String(value);
+            } else if (key === "value" || key === "checked") {
+              el[key] = value;
+            } else {
+              el.setAttribute(key, String(value));
             }
           }
-          for (let i = 0; i < children.length; i++) {
-            const dom = createDOMNode(children[i]);
-            if (dom) el.appendChild(dom);
-          }
-        } else {
-          const dom = createDOMNode(children);
-          if (dom) el.appendChild(dom);
+          const newKeyMap = reconcileKeyedChildren(el, children, void 0);
+          keyedElements.set(el, newKeyMap);
+          return;
+          return;
         }
       }
-      return el;
-    }
-    if (typeof type === "function") {
-      const frame = node[CONTEXT_FRAME_SYMBOL];
-      const snapshot = frame || getCurrentContextFrame();
-      const componentFn = type;
-      const isAsync = componentFn.constructor.name === "AsyncFunction";
-      if (isAsync) {
-        throw new Error(
-          "Async components are not supported. Use resource() for async work."
-        );
-      }
-      const vnodeAny = node;
-      let childInstance = vnodeAny.__instance;
-      if (!childInstance) {
-        childInstance = createComponentInstance(
-          `comp-${Math.random().toString(36).slice(2, 7)}`,
-          componentFn,
-          props || {},
-          null
-        );
-        vnodeAny.__instance = childInstance;
-      }
-      if (snapshot) {
-        childInstance.ownerFrame = snapshot;
-      }
-      const result = withContext(
-        snapshot,
-        () => renderComponentInline(childInstance)
-      );
-      if (result instanceof Promise) {
-        throw new Error(
-          "Async components are not supported. Components must return synchronously."
-        );
-      }
-      const dom = withContext(snapshot, () => createDOMNode(result));
-      if (dom instanceof Element) {
-        mountInstanceInline(childInstance, dom);
-      } else {
-        const host = document.createElement("div");
-        mountInstanceInline(childInstance, host);
-      }
-      return dom;
-    }
-    if (typeof type === "symbol" && (type === Fragment || String(type) === "Symbol(Fragment)")) {
-      const fragment = document.createDocumentFragment();
-      const children = props.children || node.children;
-      if (children) {
-        if (Array.isArray(children)) {
-          for (let i = 0; i < children.length; i++) {
-            const dom = createDOMNode(children[i]);
-            if (dom) fragment.appendChild(dom);
-          }
-        } else {
-          const dom = createDOMNode(children);
-          if (dom) fragment.appendChild(dom);
-        }
+      const dom = createDOMNode(vnode);
+      if (dom) {
+        target.appendChild(dom);
       }
-      return fragment;
     }
   }
-  return null;
 }
-var domRanges, elementListeners, keyedElements, _reconcilerRecordedParents;
-var init_dom = __esm({
-  "src/renderer/dom.ts"() {
+var domRanges;
+var init_evaluate = __esm({
+  "src/renderer/evaluate.ts"() {
     "use strict";
     init_scheduler();
-    init_fastlane();
     init_logger();
-    init_jsx_runtime();
-    init_context();
-    init_component();
+    init_cleanup();
+    init_keyed();
+    init_reconcile();
+    init_types();
+    init_dom();
+    init_diag();
     domRanges = /* @__PURE__ */ new WeakMap();
-    elementListeners = /* @__PURE__ */ new WeakMap();
-    keyedElements = /* @__PURE__ */ new WeakMap();
-    _reconcilerRecordedParents = /* @__PURE__ */ new WeakSet();
+  }
+});
+
+// src/renderer/index.ts
+var init_renderer = __esm({
+  "src/renderer/index.ts"() {
+    "use strict";
+    init_types();
+    init_cleanup();
+    init_keyed();
+    init_dom();
+    init_evaluate();
+    init_evaluate();
+    init_keyed();
     if (typeof globalThis !== "undefined") {
       const _g = globalThis;
       _g.__ASKR_RENDERER = {
@@ -2736,22 +2253,6 @@ var init_dom = __esm({
 });
 
 // src/runtime/component.ts
-var component_exports = {};
-__export(component_exports, {
-  cleanupComponent: () => cleanupComponent,
-  createComponentInstance: () => createComponentInstance,
-  executeComponent: () => executeComponent,
-  finalizeReadSubscriptions: () => finalizeReadSubscriptions,
-  getCurrentComponentInstance: () => getCurrentComponentInstance,
-  getCurrentInstance: () => getCurrentInstance,
-  getNextStateIndex: () => getNextStateIndex,
-  getSignal: () => getSignal,
-  mountComponent: () => mountComponent,
-  mountInstanceInline: () => mountInstanceInline,
-  registerMountOperation: () => registerMountOperation,
-  renderComponentInline: () => renderComponentInline,
-  setCurrentComponentInstance: () => setCurrentComponentInstance
-});
 function createComponentInstance(id, fn, props, target) {
   const instance = {
     id,
@@ -2777,6 +2278,7 @@ function createComponentInstance(id, fn, props, target) {
     ownerFrame: null,
     // Will be set by renderer when vnode is marked
     ssr: false,
+    cleanupStrict: false,
     isRoot: false,
     // Render-tracking (for precise state subscriptions)
     _currentRenderToken: void 0,
@@ -2871,12 +2373,41 @@ function runComponent(instance) {
     }
     globalScheduler.enqueue(() => {
       if (instance.target) {
+        let oldChildren = [];
         try {
           const wasFirstMount = !instance.mounted;
           const oldInstance = currentInstance;
           currentInstance = instance;
+          oldChildren = Array.from(instance.target.childNodes);
           try {
             evaluate(result, instance.target);
+          } catch (e) {
+            try {
+              const newChildren = Array.from(instance.target.childNodes);
+              for (const n of newChildren) {
+                try {
+                  cleanupInstancesUnder(n);
+                } catch (err) {
+                  logger.warn(
+                    "[Askr] error cleaning up failed commit children:",
+                    err
+                  );
+                }
+              }
+            } catch (_err) {
+              void _err;
+            }
+            try {
+              __ASKR_incCounter("__DOM_REPLACE_COUNT");
+              __ASKR_set(
+                "__LAST_DOM_REPLACE_STACK_COMPONENT_RESTORE",
+                new Error().stack
+              );
+            } catch (e2) {
+              void e2;
+            }
+            instance.target.replaceChildren(...oldChildren);
+            throw e;
           } finally {
             currentInstance = oldInstance;
           }
@@ -2886,7 +2417,35 @@ function runComponent(instance) {
             executeMountOperations(instance);
           }
         } catch (renderError) {
-          instance.target.innerHTML = domSnapshot;
+          try {
+            const currentChildren = Array.from(instance.target.childNodes);
+            for (const n of currentChildren) {
+              try {
+                cleanupInstancesUnder(n);
+              } catch (err) {
+                logger.warn(
+                  "[Askr] error cleaning up partial children during rollback:",
+                  err
+                );
+              }
+            }
+          } catch (_err) {
+            void _err;
+          }
+          try {
+            try {
+              __ASKR_incCounter("__DOM_REPLACE_COUNT");
+              __ASKR_set(
+                "__LAST_DOM_REPLACE_STACK_COMPONENT_ROLLBACK",
+                new Error().stack
+              );
+            } catch (e) {
+              void e;
+            }
+            instance.target.replaceChildren(...oldChildren);
+          } catch {
+            instance.target.innerHTML = domSnapshot;
+          }
           throw renderError;
         }
       }
@@ -2935,21 +2494,24 @@ function executeComponentSync(instance) {
       executionFrame,
       () => instance.fn(instance.props, context)
     );
-    if (process.env.NODE_ENV !== "production") {
-      const renderTime = Date.now() - renderStartTime;
-      if (renderTime > 5) {
-        logger.warn(
-          `[askr] Slow render detected: ${renderTime}ms. Consider optimizing component performance.`
-        );
-      }
+    const renderTime = Date.now() - renderStartTime;
+    if (renderTime > 5) {
+      logger.warn(
+        `[askr] Slow render detected: ${renderTime}ms. Consider optimizing component performance.`
+      );
     }
     if (!instance.firstRenderComplete) {
       instance.firstRenderComplete = true;
     }
-    if (process.env.NODE_ENV !== "production") {
-      for (let i = 0; i < instance.stateValues.length; i++) {
-        const state = instance.stateValues[i];
-        if (state && !state._hasBeenRead) {
+    for (let i = 0; i < instance.stateValues.length; i++) {
+      const state = instance.stateValues[i];
+      if (state && !state._hasBeenRead) {
+        try {
+          const name = instance.fn?.name || "<anonymous>";
+          logger.warn(
+            `[askr] Unused state variable detected in ${name} at index ${i}. State should be read during render or removed.`
+          );
+        } catch {
           logger.warn(
             `[askr] Unused state variable detected. State should be read during render or removed.`
           );
@@ -2984,13 +2546,13 @@ function finalizeReadSubscriptions(instance) {
   if (token === void 0) return;
   for (const s of oldSet) {
     if (!newSet.has(s)) {
-      const readers = s?._readers;
+      const readers = s._readers;
       if (readers) readers.delete(instance);
     }
   }
   instance.lastRenderToken = token;
   for (const s of newSet) {
-    let readers = s?._readers;
+    let readers = s._readers;
     if (!readers) {
       readers = /* @__PURE__ */ new Map();
       s._readers = readers;
@@ -3008,13 +2570,30 @@ function mountComponent(instance) {
   executeComponent(instance);
 }
 function cleanupComponent(instance) {
+  const cleanupErrors = [];
   for (const cleanup of instance.cleanupFns) {
-    cleanup();
+    try {
+      cleanup();
+    } catch (err) {
+      if (instance.cleanupStrict) {
+        cleanupErrors.push(err);
+      } else {
+        if (process.env.NODE_ENV !== "production") {
+          logger.warn("[Askr] cleanup function threw:", err);
+        }
+      }
+    }
   }
   instance.cleanupFns = [];
+  if (cleanupErrors.length > 0) {
+    throw new AggregateError(
+      cleanupErrors,
+      `Cleanup failed for component ${instance.id}`
+    );
+  }
   if (instance._lastReadStates) {
     for (const s of instance._lastReadStates) {
-      const readers = s?._readers;
+      const readers = s._readers;
       if (readers) readers.delete(instance);
     }
     instance._lastReadStates = /* @__PURE__ */ new Set();
@@ -3025,11 +2604,12 @@ var currentInstance, stateIndex, _globalRenderCounter;
 var init_component = __esm({
   "src/runtime/component.ts"() {
     "use strict";
-    init_dom();
     init_scheduler();
     init_context();
     init_logger();
-    init_fastlane();
+    init_diag();
+    init_fastlane_shared();
+    init_renderer();
     currentInstance = null;
     stateIndex = 0;
     _globalRenderCounter = 0;
@@ -3253,7 +2833,7 @@ function route(path, handler, namespace) {
   }
   if (registrationLocked) {
     throw new Error(
-      "Route registration is locked after app startup. Register routes at module load time before calling createApp()."
+      "Route registration is locked after app startup. Register routes at module load time before calling createIsland()."
     );
   }
   if (typeof handler !== "function") {
@@ -3407,18 +2987,19 @@ export {
   globalScheduler,
   scheduleEventHandler,
   init_scheduler,
-  isBulkCommitActive2 as isBulkCommitActive,
-  init_fastlane,
   withAsyncResourceContext,
   defineContext,
   readContext,
   getCurrentContextFrame,
   init_context,
+  isBulkCommitActive2 as isBulkCommitActive,
+  init_fastlane_shared,
   removeAllListeners,
-  init_dom,
+  init_renderer,
   createComponentInstance,
   getCurrentComponentInstance,
   setCurrentComponentInstance,
+  registerMountOperation,
   getCurrentInstance,
   getSignal,
   getNextStateIndex,
@@ -3439,4 +3020,4 @@ export {
   resolveRoute,
   route_exports
 };
-//# sourceMappingURL=chunk-L7RL4LYV.js.map
+//# sourceMappingURL=chunk-MIPES65F.js.map