@askrjs/askr 0.0.1 → 0.0.2

package/dist/index.cjs

@@ -136,9 +136,9 @@ var init_scheduler = __esm({
         // Keep a lightweight taskCount for compatibility/diagnostics
         this.taskCount = 0;
       }
-      enqueue(task) {
+      enqueue(task2) {
         assertSchedulingPrecondition(
-          typeof task === "function",
+          typeof task2 === "function",
           "enqueue() requires a function"
         );
         if (isBulkCommitActive() && !this.allowSyncProgress) {
@@ -149,7 +149,7 @@ var init_scheduler = __esm({
           }
           return;
         }
-        this.q.push(task);
+        this.q.push(task2);
         this.taskCount++;
         if (!this.running && !this.kickScheduled && !this.inHandler && !isBulkCommitActive()) {
           this.kickScheduled = true;
@@ -190,10 +190,10 @@ var init_scheduler = __esm({
                 `[Scheduler] exceeded MAX_FLUSH_DEPTH (${MAX_FLUSH_DEPTH}). Likely infinite update loop.`
               );
             }
-            const task = this.q[this.head++];
+            const task2 = this.q[this.head++];
             try {
               this.executionDepth++;
-              task();
+              task2();
               this.executionDepth--;
             } catch (err) {
               if (this.executionDepth > 0) this.executionDepth = 0;
@@ -279,17 +279,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(
@@ -366,267 +363,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/jsx/jsx-runtime.ts
-function jsx(type, props, key) {
-  return {
-    type,
-    props: props || {},
-    key
-  };
-}
-function jsxs(type, props, key) {
-  return jsx(type, props, key);
-}
-var Fragment;
-var init_jsx_runtime = __esm({
-  "src/jsx/jsx-runtime.ts"() {
-    "use strict";
-    Fragment = /* @__PURE__ */ Symbol.for("@askrjs/askr.Fragment");
-  }
-});
-
 // src/runtime/context.ts
 function withContext(frame, fn) {
   const oldFrame = currentContextFrame;
@@ -652,9 +388,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 }
       };
     }
   };
@@ -690,29 +427,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);
   }
@@ -756,22 +493,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("*");
@@ -779,32 +620,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);
   }
@@ -817,252 +683,32 @@ 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 current2 = range.start.nextSibling;
-    while (current2 && current2 !== range.end) {
-      const next = current2.nextSibling;
-      current2.remove();
-      current2 = 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 {
-                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 });
+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 totalKeyed = keyedVnodes.length;
@@ -1113,8 +759,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;
@@ -1128,8 +775,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;
@@ -1158,8 +806,9 @@ function isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap) {
             break;
           }
         }
-      } catch {
+      } catch (e) {
         hasPropChanges = true;
+        void e;
         break;
       }
     }
@@ -1174,1024 +823,421 @@ 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/jsx/types.ts
+var ELEMENT_TYPE, Fragment;
+var init_types2 = __esm({
+  "src/jsx/types.ts"() {
+    "use strict";
+    ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("askr.element");
+    Fragment = /* @__PURE__ */ Symbol.for("askr.fragment");
   }
-  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;
+});
+
+// src/jsx/jsx-runtime.ts
+function jsxDEV(type, props, key) {
+  return {
+    $$typeof: ELEMENT_TYPE2,
+    type,
+    props: props ?? {},
+    key: key ?? null
+  };
+}
+function jsx(type, props, key) {
+  return jsxDEV(type, props, key);
+}
+function jsxs(type, props, key) {
+  return jsxDEV(type, props, key);
+}
+var ELEMENT_TYPE2, Fragment2;
+var init_jsx_runtime = __esm({
+  "src/jsx/jsx-runtime.ts"() {
+    "use strict";
+    init_types2();
+    ELEMENT_TYPE2 = /* @__PURE__ */ Symbol.for("askr.element");
+    Fragment2 = /* @__PURE__ */ Symbol.for("askr.fragment");
   }
-  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;
+});
+
+// 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;
       }
     }
-  } catch (e) {
-    void e;
+    return null;
   }
-  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 === "string") {
+    return document.createTextNode(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 (typeof node === "number") {
+    return document.createTextNode(String(node));
   }
-  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 (!node) {
+    return null;
+  }
+  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 state2 = globalScheduler.getState();
+              if ((state2.queueLength ?? 0) > 0 && !state2.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") {
+            if (hasElements && !hasKeys) {
+              if (typeof console !== "undefined") {
                 try {
-                  const gl = globalThis;
-                  gl.__ASKR_BULK_DIAG = {
-                    phase: "bulk-keyed-positional-trigger-lenmatch",
-                    totalKeyed: keyedVnodes.length,
-                    keyMismatches
-                  };
+                  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;
                 }
               }
-              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;
-            }
-            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;
-            }
-          }
-        }
-      } catch {
-        stable = false;
-      }
-    }
-  } 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");
-      }
-      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 current2 = existingChildren[i];
-            if (current2 && _isDOMElement(vnode)) {
-              const vnodeType = vnode.type;
-              if (current2.tagName.toLowerCase() === vnodeType.toLowerCase()) {
-                updateElementFromVnode(current2, vnode);
-                newKeyMap.set(key, current2);
-                continue;
-              }
             }
-            const newEl = createDOMNode(vnode);
-            if (newEl instanceof Element) {
-              if (current2) {
-                cleanupInstanceIfPresent(current2);
-                parent.replaceChild(newEl, current2);
-              } else parent.appendChild(newEl);
-              newKeyMap.set(key, newEl);
-            }
-          }
-          for (const vnode of unkeyedVnodes) {
-            const newEl = createDOMNode(vnode);
-            if (newEl) parent.appendChild(newEl);
-          }
-          return newKeyMap;
-        }
-      }
-    } catch {
-    }
-  }
-  if (useFastPath) {
-    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 {
-        parentChildrenArr = void 0;
-      }
-    } 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;
-      }
-    }
-    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;
+          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);
         }
-        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++;
-        }
-      }
-    }
-    for (const vnode of unkeyedVnodes) {
-      const newEl = createDOMNode(vnode);
-      if (newEl) {
-        finalNodes.push(newEl);
-        createdNodes++;
       }
+      return el;
     }
-    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;
-        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;
-        }
-      } finally {
-        violation = otherMutationCount !== 0 || replaceChildrenCount < 1;
-      }
-      if (violation) {
-        logger.error(
-          "[Askr][DEV] Fast-path structural mutation invariant violated:",
-          {
-            replaceChildrenCount,
-            otherMutationCount
-          }
-        );
+    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(
-          "Fast-path must perform a single structural replacement (replaceChildren) and no other structural mutations"
+          "Async components are not supported. Use resource() for async work."
         );
       }
-    } 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;
+      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;
       }
-      try {
-        const existing = Array.from(parent.childNodes);
-        for (const n of existing) cleanupInstanceIfPresent(n);
-      } catch (e) {
-        void e;
+      if (snapshot) {
+        childInstance.ownerFrame = snapshot;
       }
-      parent.replaceChildren(fragment);
-      if (typeof globalThis !== "undefined") {
-        globalThis["__ASKR_LAST_FASTPATH_COMMIT_COUNT"] = commitCount;
+      const result = withContext(
+        snapshot,
+        () => renderComponentInline(childInstance)
+      );
+      if (result instanceof Promise) {
+        throw new Error(
+          "Async components are not supported. Components must return synchronously."
+        );
       }
-      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 dom = withContext(snapshot, () => createDOMNode(result));
+      if (dom instanceof Element) {
+        mountInstanceInline(childInstance, dom);
+        return dom;
       }
-      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 host = document.createElement("div");
+      if (dom instanceof DocumentFragment) {
+        host.appendChild(dom);
+      } else if (dom) {
+        host.appendChild(dom);
       }
-      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;
+      mountInstanceInline(childInstance, host);
+      return host;
+    }
+    if (typeof type === "symbol" && (type === Fragment2 || 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);
           }
-          hist.push(stats);
+        } else {
+          const dom = createDOMNode(children);
+          if (dom) fragment.appendChild(dom);
         }
-        logger.warn("[Askr][FASTPATH]", JSON.stringify(stats));
       }
+      return fragment;
     }
-    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;
-    }
-    prev[i] = lo > 0 ? tailsIdx[lo - 1] : -1;
   }
-  let k = tailsIdx.length ? tailsIdx[tailsIdx.length - 1] : -1;
-  while (k !== -1) {
-    keepSet.add(k);
-    k = prev[k];
+  return null;
+}
+function updateElementFromVnode(el, vnode, updateChildren = true) {
+  if (!_isDOMElement(vnode)) {
+    return;
   }
-  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;
-    }
+  const props = vnode.props || {};
+  const vnodeKey = vnode.key ?? vnode.props?.key;
+  if (vnodeKey !== void 0) {
+    el.setAttribute("data-key", String(vnodeKey));
   }
-  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;
+  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);
         }
-        updateElementFromVnode(el, vnode);
-        newKeyMap.set(key, el);
+        continue;
       } else {
-        parent.insertBefore(el, anchor);
-        updateElementFromVnode(el, vnode);
-        newKeyMap.set(key, el);
-        anchor = el.nextSibling;
+        el.removeAttribute(key);
       }
-    } else {
-      const newEl = createDOMNode(vnode);
-      if (newEl instanceof Element) {
-        parent.insertBefore(newEl, anchor);
-        newKeyMap.set(key, newEl);
-        anchor = newEl.nextSibling;
+      continue;
+    }
+    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);
+        }
+      };
+      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 {
+      el.setAttribute(key, String(value));
     }
   }
-  for (const vnode of unkeyedVnodes) {
-    const newEl = createDOMNode(vnode);
-    if (newEl) {
-      parent.appendChild(newEl);
+  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 (existingListeners.size === 0) elementListeners.delete(el);
   }
-  return newKeyMap;
-}
-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]);
-        } else {
-          el.textContent = String(children[0]);
-        }
-      } else {
-        updateElementFromVnode(el, vnode);
-      }
-      finalNodes.push(el);
-      reused++;
+  if (updateChildren) {
+    const children = vnode.children || props.children;
+    updateElementChildren(el, children);
+  }
+}
+function updateElementChildren(el, children) {
+  if (!children) {
+    el.textContent = "";
+    return;
+  }
+  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 dom = createDOMNode(vnode);
-      if (dom) {
-        finalNodes.push(dom);
-        created++;
-      }
+      el.textContent = String(children);
     }
+    return;
   }
-  try {
-    const toRemove = Array.from(parent.childNodes).filter(
-      (n) => !finalNodes.includes(n)
-    );
-    for (const n of toRemove) cleanupInstanceIfPresent(n);
-  } catch (e) {
-    void e;
+  if (Array.isArray(children)) {
+    updateUnkeyedChildren(el, children);
+    return;
   }
-  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;
+  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 = "";
   }
-  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);
+  const max = Math.max(existing.length, newChildren.length);
+  for (let i = 0; i < max; i++) {
+    const current2 = existing[i];
+    const next = newChildren[i];
+    if (next === void 0 && current2) {
+      cleanupInstanceIfPresent(current2);
+      current2.remove();
+      continue;
+    }
+    if (!current2 && next !== void 0) {
+      const dom = createDOMNode(next);
+      if (dom) parent.appendChild(dom);
+      continue;
+    }
+    if (!current2 || next === void 0) continue;
+    if (typeof next === "string" || typeof next === "number") {
+      current2.textContent = String(next);
+    } else if (_isDOMElement(next)) {
+      if (typeof next.type === "string") {
+        if (current2.tagName.toLowerCase() === next.type.toLowerCase()) {
+          updateElementFromVnode(current2, next);
+        } else {
+          const dom = createDOMNode(next);
+          if (dom) {
+            if (current2 instanceof Element) removeAllListeners(current2);
+            cleanupInstanceIfPresent(current2);
+            parent.replaceChild(dom, current2);
+          }
+        }
+      } else {
+        const dom = createDOMNode(next);
+        if (dom) {
+          if (current2 instanceof Element) removeAllListeners(current2);
+          cleanupInstanceIfPresent(current2);
+          parent.replaceChild(dom, current2);
         }
       }
+    } else {
+      const dom = createDOMNode(next);
+      if (dom) {
+        if (current2 instanceof Element) removeAllListeners(current2);
+        cleanupInstanceIfPresent(current2);
+        parent.replaceChild(dom, current2);
+      }
     }
-  } 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;
@@ -2205,6 +1251,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);
@@ -2228,6 +1286,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);
@@ -2251,12 +1330,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) {
@@ -2266,12 +1432,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;
       }
@@ -2290,11 +1456,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;
           }
@@ -2323,438 +1489,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++;
+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;
+    }
+  } 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;
     }
-    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]);
+  }
+  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;
+        }
+      }
+      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++;
+      }
+    }
+  }
+  if (unkeyedVnodes && unkeyedVnodes.length) {
+    for (const vnode of unkeyedVnodes) {
+      const newEl = createDOMNode(vnode);
+      if (newEl) {
+        finalNodes.push(newEl);
+        createdNodes++;
+      }
+    }
+  }
+  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;
+  }
+}
+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();
+  }
+});
+
+// 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 {
+      unkeyedVnodes.push(child);
+    }
+  }
+  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 {
-            updateElementFromVnode(el, vnode);
+            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 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;
+      }
+    }
+    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;
+    }
+    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);
-          reused++;
+          newKeyMap.set(key, el);
           continue;
         }
-        const dom2 = createDOMNode(vnode);
+        const dom2 = createDOMNode(child);
         if (dom2) {
           finalNodes.push(dom2);
-          created++;
+          if (dom2 instanceof Element) newKeyMap.set(key, dom2);
         }
         continue;
       }
     }
-    const dom = createDOMNode(vnode);
-    if (dom) {
-      finalNodes.push(dom);
-      created++;
+    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);
+  }
+  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;
   }
-  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);
+    __ASKR_incCounter("__DOM_REPLACE_COUNT");
+    __ASKR_set("__LAST_DOM_REPLACE_STACK_RECONCILE", new Error().stack);
   } 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;
+  return newKeyMap;
 }
-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));
+var init_reconcile = __esm({
+  "src/renderer/reconcile.ts"() {
+    "use strict";
+    init_dom();
+    init_keyed();
+    init_cleanup();
+    init_fastlane_shared();
+    init_diag();
+    init_fastpath();
   }
-  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);
-        }
-        continue;
-      } else {
-        el.removeAttribute(key);
+});
+
+// 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;
       }
-      continue;
     }
-    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
-      });
-    } else {
-      el.setAttribute(key, String(value));
-    }
-  }
-  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 (existingListeners.size === 0) elementListeners.delete(el);
-  }
-  if (updateChildren) {
-    const children = vnode.children || props.children;
-    updateElementChildren(el, children);
-  }
-}
-function updateElementChildren(el, children) {
-  if (!children) {
-    el.textContent = "";
     return;
   }
-  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 {
-      el.textContent = String(children);
-    }
-    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 = "";
-  }
-  const max = Math.max(existing.length, newChildren.length);
-  for (let i = 0; i < max; i++) {
-    const current2 = existing[i];
-    const next = newChildren[i];
-    if (next === void 0 && current2) {
-      cleanupInstanceIfPresent(current2);
+  if (context && domRanges.has(context)) {
+    const range = domRanges.get(context);
+    let current2 = range.start.nextSibling;
+    while (current2 && current2 !== range.end) {
+      const next = current2.nextSibling;
       current2.remove();
-      continue;
+      current2 = next;
     }
-    if (!current2 && next !== void 0) {
-      const dom = createDOMNode(next);
-      if (dom) parent.appendChild(dom);
-      continue;
+    const dom = createDOMNode(node);
+    if (dom) {
+      target.insertBefore(dom, range.end);
     }
-    if (!current2 || next === void 0) continue;
-    if (typeof next === "string" || typeof next === "number") {
-      current2.textContent = String(next);
-    } else if (_isDOMElement(next)) {
-      if (typeof next.type === "string") {
-        if (current2.tagName.toLowerCase() === next.type.toLowerCase()) {
-          updateElementFromVnode(current2, next);
-        } else {
-          const dom = createDOMNode(next);
-          if (dom) {
-            cleanupInstanceIfPresent(current2);
-            parent.replaceChild(dom, current2);
-          }
+  } 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 {
-        const dom = createDOMNode(next);
-        if (dom) {
-          cleanupInstanceIfPresent(current2);
-          parent.replaceChild(dom, current2);
+      } else if (vnodeChildren.length === 1) {
+        const child = vnodeChildren[0];
+        if (typeof child === "string" || typeof child === "number") {
+          isSimpleTextVNode = true;
+          textContent = String(child);
         }
       }
-    } else {
-      const dom = createDOMNode(next);
-      if (dom) {
-        cleanupInstanceIfPresent(current2);
-        parent.replaceChild(dom, current2);
-      }
-    }
-  }
-}
-function createDOMNode(node) {
-  if (typeof node === "string") {
-    return document.createTextNode(node);
-  }
-  if (typeof node === "number") {
-    return document.createTextNode(String(node));
-  }
-  if (!node) {
-    return null;
-  }
-  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;
-  }
-  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 state2 = globalScheduler.getState();
-              if ((state2.queueLength ?? 0) > 0 && !state2.running) {
-                queueMicrotask(() => {
+      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 {
-                    if (!globalScheduler.isExecuting()) globalScheduler.flush();
+                    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) {
-                    setTimeout(() => {
-                      throw 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 {
+                    __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 = {
@@ -2767,22 +2301,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,
@@ -2808,6 +2326,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,
@@ -2902,12 +2421,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;
           }
@@ -2917,7 +2465,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;
         }
       }
@@ -2966,21 +2542,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 state2 = instance.stateValues[i];
-        if (state2 && !state2._hasBeenRead) {
+    for (let i = 0; i < instance.stateValues.length; i++) {
+      const state2 = instance.stateValues[i];
+      if (state2 && !state2._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.`
           );
@@ -3015,13 +2594,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;
@@ -3039,13 +2618,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();
@@ -3056,11 +2652,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;
@@ -3387,7 +2984,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") {
@@ -3737,9 +3334,14 @@ function renderChildrenToSink(children, sink, ctx) {
       ctx
     );
 }
+function isPromiseLike(x) {
+  if (!x || typeof x !== "object") return false;
+  const then = x.then;
+  return typeof then === "function";
+}
 function executeComponent2(type, props, ctx) {
   const res = type(props ?? {}, { signal: ctx.signal });
-  if (res && typeof res === "object" && "then" in res && typeof res.then === "function") {
+  if (isPromiseLike(res)) {
     throwSSRDataMissing();
   }
   return res;
@@ -3809,6 +3411,8 @@ var ssr_exports = {};
 __export(ssr_exports, {
   SSRDataMissingError: () => SSRDataMissingError,
   collectResources: () => collectResources,
+  popSSRStrictPurityGuard: () => popSSRStrictPurityGuard,
+  pushSSRStrictPurityGuard: () => pushSSRStrictPurityGuard,
   renderToStream: () => renderToStream,
   renderToString: () => renderToString,
   renderToStringSync: () => renderToStringSync,
@@ -3816,6 +3420,31 @@ __export(ssr_exports, {
   resolvePlan: () => resolvePlan,
   resolveResources: () => resolveResources
 });
+function pushSSRStrictPurityGuard() {
+  if (process.env.NODE_ENV === "production") return;
+  __ssrGuardStack.push({
+    random: Reflect.get(Math, "random"),
+    now: Reflect.get(Date, "now")
+  });
+  Reflect.set(Math, "random", () => {
+    throw new Error(
+      "SSR Strict Purity: Math.random is not allowed during synchronous SSR. Use the provided `ssr` context RNG instead."
+    );
+  });
+  Reflect.set(Date, "now", () => {
+    throw new Error(
+      "SSR Strict Purity: Date.now is not allowed during synchronous SSR. Pass timestamps explicitly or use deterministic helpers."
+    );
+  });
+}
+function popSSRStrictPurityGuard() {
+  if (process.env.NODE_ENV === "production") return;
+  const prev = __ssrGuardStack.pop();
+  if (prev) {
+    Reflect.set(Math, "random", prev.random);
+    Reflect.set(Date, "now", prev.now);
+  }
+}
 function escapeText2(text) {
   const cached = escapeCache2.get(text);
   if (cached) return cached;
@@ -3893,20 +3522,9 @@ function renderNodeSync(node, ctx) {
   return `<${typeStr}${attrs}>${childrenHtml}</${typeStr}>`;
 }
 function executeComponentSync2(component, props, ctx) {
-  const originalRandom = Math.random;
-  const originalDateNow = Date.now;
   try {
     if (process.env.NODE_ENV !== "production") {
-      Math.random = () => {
-        throw new Error(
-          "SSR Strict Purity: Math.random is not allowed during synchronous SSR. Use the provided `ssr` context RNG instead."
-        );
-      };
-      Date.now = () => {
-        throw new Error(
-          "SSR Strict Purity: Date.now is not allowed during synchronous SSR. Pass timestamps explicitly or use deterministic helpers."
-        );
-      };
+      pushSSRStrictPurityGuard();
     }
     const prev = getCurrentComponentInstance();
     const temp = createComponentInstance(
@@ -3929,8 +3547,7 @@ function executeComponentSync2(component, props, ctx) {
       setCurrentComponentInstance(prev);
     }
   } finally {
-    Math.random = originalRandom;
-    Date.now = originalDateNow;
+    if (process.env.NODE_ENV !== "production") popSSRStrictPurityGuard();
   }
 }
 function renderToStringSync(component, props, options) {
@@ -4023,7 +3640,7 @@ function renderToSinkInternal(opts) {
     stopRenderPhase();
   }
 }
-var VOID_ELEMENTS2, escapeCache2;
+var VOID_ELEMENTS2, escapeCache2, __ssrGuardStack;
 var init_ssr = __esm({
   "src/ssr/index.ts"() {
     "use strict";
@@ -4051,21 +3668,24 @@ var init_ssr = __esm({
       "wbr"
     ]);
     escapeCache2 = /* @__PURE__ */ new Map();
+    __ssrGuardStack = [];
   }
 });
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  Fragment: () => Fragment,
+  Fragment: () => Fragment2,
   Link: () => Link,
+  Slot: () => Slot,
   cleanupApp: () => cleanupApp,
   clearRoutes: () => clearRoutes,
   collectResources: () => collectResources,
-  createApp: () => createApp,
   createIsland: () => createIsland,
   createSPA: () => createSPA,
   defineContext: () => defineContext,
+  definePortal: () => definePortal,
+  derive: () => derive,
   getLoadedNamespaces: () => getLoadedNamespaces,
   getNamespaceRoutes: () => getNamespaceRoutes,
   getRoutes: () => getRoutes,
@@ -4087,6 +3707,7 @@ __export(index_exports, {
   scheduleEventHandler: () => scheduleEventHandler,
   setServerLocation: () => setServerLocation,
   state: () => state,
+  task: () => task,
   unloadNamespace: () => unloadNamespace
 });
 module.exports = __toCommonJS(index_exports);
@@ -4095,7 +3716,7 @@ module.exports = __toCommonJS(index_exports);
 init_scheduler();
 init_component();
 init_invariant();
-init_fastlane();
+init_fastlane_shared();
 function state(initialValue) {
   const instance = getCurrentInstance();
   if (!instance) {
@@ -4151,7 +3772,7 @@ function createStateCell(initialValue, instance) {
   }
   read._readers = readers;
   read._owner = instance;
-  read.set = (newValue) => {
+  read.set = (newValueOrUpdater) => {
     const currentInst = getCurrentInstance();
     if (currentInst !== null && process.env.NODE_ENV !== "production") {
       throw new Error(
@@ -4161,6 +3782,13 @@ function createStateCell(initialValue, instance) {
     if (currentInst !== null && process.env.NODE_ENV === "production") {
       return;
     }
+    let newValue;
+    if (typeof newValueOrUpdater === "function") {
+      const updater = newValueOrUpdater;
+      newValue = updater(value);
+    } else {
+      newValue = newValueOrUpdater;
+    }
     if (Object.is(value, newValue)) return;
     if (isBulkCommitActive2()) {
       value = newValue;
@@ -4191,8 +3819,8 @@ function createStateCell(initialValue, instance) {
     );
     if (ownerShouldEnqueue && !instance.hasPendingUpdate) {
       instance.hasPendingUpdate = true;
-      const task = instance._pendingFlushTask;
-      if (task) globalScheduler.enqueue(task);
+      const task2 = instance._pendingFlushTask;
+      if (task2) globalScheduler.enqueue(task2);
       else
         globalScheduler.enqueue(() => {
           instance.hasPendingUpdate = false;
@@ -4288,7 +3916,14 @@ var ResourceCell = class {
       this.pending = false;
       this.error = err;
       try {
-        logger.error("[Askr] Async resource error:", err);
+        if (this.ownerName) {
+          logger.error(
+            `[Askr] Async resource error in ${this.ownerName}:`,
+            err
+          );
+        } else {
+          logger.error("[Askr] Async resource error:", err);
+        }
       } catch {
       }
       this.notifySubscribers();
@@ -4304,6 +3939,17 @@ var ResourceCell = class {
   }
 };
 
+// src/shared/derive_cache.ts
+var deriveCacheMap = /* @__PURE__ */ new WeakMap();
+function getDeriveCache(instance) {
+  let cache = deriveCacheMap.get(instance);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    deriveCacheMap.set(instance, cache);
+  }
+  return cache;
+}
+
 // src/runtime/operations.ts
 init_context2();
 init_data();
@@ -4376,6 +4022,7 @@ function resource(fn, deps = []) {
   if (!h.cell) {
     const frame = getCurrentContextFrame();
     const cell2 = new ResourceCell(fn, deps, frame);
+    cell2.ownerName = inst.fn?.name || "<anonymous>";
     h.cell = cell2;
     h.snapshot = cell2.snapshot;
     const unsubscribe = cell2.subscribe(() => {
@@ -4438,35 +4085,101 @@ function resource(fn, deps = []) {
   }
   return h.snapshot;
 }
+function derive(source, map) {
+  if (map === void 0 && typeof source === "function") {
+    const value2 = source();
+    if (value2 == null) return null;
+    const instance2 = getCurrentComponentInstance();
+    if (!instance2) {
+      return value2;
+    }
+    const cache2 = getDeriveCache(instance2);
+    if (cache2.has(value2)) return cache2.get(value2);
+    cache2.set(value2, value2);
+    return value2;
+  }
+  let value;
+  if (typeof source === "function" && !("value" in source)) {
+    value = source();
+  } else {
+    value = source?.value ?? source;
+  }
+  if (value == null) return null;
+  const instance = getCurrentComponentInstance();
+  if (!instance) {
+    return map(value);
+  }
+  const cache = getDeriveCache(instance);
+  if (cache.has(value)) {
+    return cache.get(value);
+  }
+  const result = map(value);
+  cache.set(value, result);
+  return result;
+}
+function task(fn) {
+  const ownerIsRoot = getCurrentComponentInstance()?.isRoot ?? false;
+  registerMountOperation(async () => {
+    if (!ownerIsRoot) {
+      throw new Error("[Askr] task() may only be used in root components");
+    }
+    return await fn();
+  });
+}
 
-// src/app/createApp.ts
+// src/boot/index.ts
 init_component();
 init_scheduler();
 init_logger();
-init_dom();
 init_navigate();
+init_renderer();
 var componentIdCounter = 0;
 var instancesByRoot = /* @__PURE__ */ new WeakMap();
 var CLEANUP_SYMBOL = /* @__PURE__ */ Symbol.for("__tempoCleanup__");
-function createApp(config) {
-  if (!config || typeof config !== "object") {
-    throw new Error("createApp requires a config object");
-  }
-  if ("routes" in config) {
-    throw new Error(
-      "The `createApp` API is removed. Use `createSPA({ root, routes })` for routed apps, or `hydrateSPA({ root, routes })` for SSR hydration."
-    );
-  }
-  const appCfg = config;
-  createIsland({
-    root: appCfg.root,
-    component: appCfg.component
-  });
-}
 function attachCleanupForRoot(rootElement, instance) {
   rootElement[CLEANUP_SYMBOL] = () => {
-    removeAllListeners(rootElement);
-    cleanupComponent(instance);
+    const errors = [];
+    try {
+      removeAllListeners(rootElement);
+    } catch (e) {
+      errors.push(e);
+    }
+    try {
+      const descendants = rootElement.querySelectorAll("*");
+      for (const d of Array.from(descendants)) {
+        try {
+          const inst = d.__ASKR_INSTANCE;
+          if (inst) {
+            try {
+              cleanupComponent(inst);
+            } catch (err) {
+              errors.push(err);
+            }
+            try {
+              delete d.__ASKR_INSTANCE;
+            } catch (err) {
+              errors.push(err);
+            }
+          }
+        } catch (err) {
+          errors.push(err);
+        }
+      }
+    } catch (e) {
+      errors.push(e);
+    }
+    try {
+      cleanupComponent(instance);
+    } catch (e) {
+      errors.push(e);
+    }
+    if (errors.length > 0) {
+      if (instance.cleanupStrict) {
+        throw new AggregateError(errors, `cleanup failed for app root`);
+      } else if (process.env.NODE_ENV !== "production") {
+        for (const err of errors) logger.warn("[Askr] cleanup error:", err);
+      }
+    }
   };
   try {
     const descriptor = Object.getOwnPropertyDescriptor(rootElement, "innerHTML") || Object.getOwnPropertyDescriptor(
@@ -4480,8 +4193,20 @@ function attachCleanupForRoot(rootElement, instance) {
         } : void 0,
         set: function(value) {
           if (value === "" && instancesByRoot.get(this) === instance) {
-            removeAllListeners(rootElement);
-            cleanupComponent(instance);
+            try {
+              removeAllListeners(rootElement);
+            } catch (e) {
+              if (instance.cleanupStrict) throw e;
+              if (process.env.NODE_ENV !== "production")
+                logger.warn("[Askr] cleanup error:", e);
+            }
+            try {
+              cleanupComponent(instance);
+            } catch (e) {
+              if (instance.cleanupStrict) throw e;
+              if (process.env.NODE_ENV !== "production")
+                logger.warn("[Askr] cleanup error:", e);
+            }
           }
           if (descriptor.set) {
             return descriptor.set.call(this, value);
@@ -4493,19 +4218,27 @@ function attachCleanupForRoot(rootElement, instance) {
   } catch {
   }
 }
-function mountOrUpdate(rootElement, componentFn) {
+function mountOrUpdate(rootElement, componentFn, options) {
   const existingCleanup = rootElement[CLEANUP_SYMBOL];
   if (existingCleanup) existingCleanup();
   let instance = instancesByRoot.get(rootElement);
   if (instance) {
     removeAllListeners(rootElement);
-    cleanupComponent(instance);
+    try {
+      cleanupComponent(instance);
+    } catch (e) {
+      if (process.env.NODE_ENV !== "production")
+        logger.warn("[Askr] prior cleanup threw:", e);
+    }
     instance.fn = componentFn;
     instance.evaluationGeneration++;
     instance.mounted = false;
     instance.expectedStateIndices = [];
     instance.firstRenderComplete = false;
     instance.isRoot = true;
+    if (options && typeof options.cleanupStrict === "boolean") {
+      instance.cleanupStrict = options.cleanupStrict;
+    }
   } else {
     const componentId = String(++componentIdCounter);
     instance = createComponentInstance(
@@ -4516,6 +4249,9 @@ function mountOrUpdate(rootElement, componentFn) {
     );
     instancesByRoot.set(rootElement, instance);
     instance.isRoot = true;
+    if (options && typeof options.cleanupStrict === "boolean") {
+      instance.cleanupStrict = options.cleanupStrict;
+    }
   }
   attachCleanupForRoot(rootElement, instance);
   mountComponent(instance);
@@ -4535,7 +4271,9 @@ function createIsland(config) {
       "createIsland does not accept routes; use createSPA for routed apps"
     );
   }
-  mountOrUpdate(rootElement, config.component);
+  mountOrUpdate(rootElement, config.component, {
+    cleanupStrict: config.cleanupStrict
+  });
 }
 async function createSPA(config) {
   if (!config || typeof config !== "object") {
@@ -4562,14 +4300,18 @@ async function createSPA(config) {
         `createSPA: no route found for current path (${path}). Mounting empty placeholder; navigation will activate routes when requested.`
       );
     }
-    mountOrUpdate(rootElement, () => ({ type: "div", children: [] }));
+    mountOrUpdate(rootElement, () => ({ type: "div", children: [] }), {
+      cleanupStrict: false
+    });
     const instance2 = instancesByRoot.get(rootElement);
     if (!instance2) throw new Error("Internal error: app instance missing");
     registerAppInstance(instance2, path);
     initializeNavigation();
     return;
   }
-  mountOrUpdate(rootElement, resolved.handler);
+  mountOrUpdate(rootElement, resolved.handler, {
+    cleanupStrict: false
+  });
   const instance = instancesByRoot.get(rootElement);
   if (!instance) throw new Error("Internal error: app instance missing");
   registerAppInstance(instance, path);
@@ -4622,7 +4364,9 @@ async function hydrateSPA(config) {
       "[Askr] Hydration mismatch detected. Server HTML does not match expected server-render output."
     );
   }
-  mountOrUpdate(rootElement, resolved.handler);
+  mountOrUpdate(rootElement, resolved.handler, {
+    cleanupStrict: false
+  });
   const { registerAppInstance: registerAppInstance2, initializeNavigation: initializeNavigation2 } = await Promise.resolve().then(() => (init_navigate(), navigate_exports));
   const instance = instancesByRoot.get(rootElement);
   if (!instance) throw new Error("Internal error: app instance missing");
@@ -4646,13 +4390,6 @@ function hasApp(root) {
 
 // src/index.ts
 init_route();
-
-// src/router/layouts.ts
-function layout(Layout) {
-  return (children) => Layout({ children });
-}
-
-// src/index.ts
 init_route();
 init_navigate();
 
@@ -4681,6 +4418,55 @@ function Link({ href, children }) {
   };
 }
 
+// src/foundations/layout.ts
+function layout(Layout) {
+  return (children, props) => Layout({ ...props, children });
+}
+
+// src/foundations/slot.ts
+init_logger();
+
+// src/jsx/index.ts
+init_types2();
+
+// src/jsx/utils.ts
+init_types2();
+function isElement(value) {
+  return typeof value === "object" && value !== null && value.$$typeof === ELEMENT_TYPE;
+}
+function cloneElement(element, props) {
+  return {
+    ...element,
+    props: { ...element.props, ...props }
+  };
+}
+
+// src/foundations/slot.ts
+function Slot(props) {
+  if (props.asChild) {
+    const { children, ...rest } = props;
+    if (isElement(children)) {
+      return cloneElement(children, rest);
+    }
+    logger.warn("<Slot asChild> expects a single JSX element child.");
+    return null;
+  }
+  return { type: Fragment, props: { children: props.children } };
+}
+
+// src/foundations/portal.ts
+function definePortal() {
+  const slot = createPortalSlot();
+  function PortalHost() {
+    return slot.read();
+  }
+  PortalHost.render = function PortalRender(props) {
+    slot.write(props.children);
+    return null;
+  };
+  return PortalHost;
+}
+
 // src/index.ts
 init_ssr();
 init_jsx_runtime();
@@ -4688,7 +4474,6 @@ init_route();
 init_navigate();
 if (typeof globalThis !== "undefined") {
   const g = globalThis;
-  if (!g.createApp) g.createApp = createApp;
   if (!g.createIsland) g.createIsland = createIsland;
   if (!g.createSPA) g.createSPA = createSPA;
   if (!g.hydrateSPA) g.hydrateSPA = hydrateSPA;
@@ -4700,13 +4485,15 @@ if (typeof globalThis !== "undefined") {
 0 && (module.exports = {
   Fragment,
   Link,
+  Slot,
   cleanupApp,
   clearRoutes,
   collectResources,
-  createApp,
   createIsland,
   createSPA,
   defineContext,
+  definePortal,
+  derive,
   getLoadedNamespaces,
   getNamespaceRoutes,
   getRoutes,
@@ -4728,6 +4515,7 @@ if (typeof globalThis !== "undefined") {
   scheduleEventHandler,
   setServerLocation,
   state,
+  task,
   unloadNamespace
 });
 //# sourceMappingURL=index.cjs.map