@askrjs/askr 0.0.2 → 0.0.3

package/dist/{chunk-MIPES65F.js → chunk-2ONGHQ7Z.js}

@@ -1,11 +1,60 @@
 import {
-  Fragment,
-  init_jsx_runtime
-} from "./chunk-KR6HG7HF.js";
+  Fragment as Fragment2
+} from "./chunk-SALJX5PZ.js";
 import {
-  __esm,
+  Fragment,
   __export
-} from "./chunk-QECQ2TF6.js";
+} from "./chunk-JHOGWTAW.js";
+
+// src/router/route.ts
+var route_exports = {};
+__export(route_exports, {
+  _lockRouteRegistrationForTests: () => _lockRouteRegistrationForTests,
+  _unlockRouteRegistrationForTests: () => _unlockRouteRegistrationForTests,
+  clearRoutes: () => clearRoutes,
+  getLoadedNamespaces: () => getLoadedNamespaces,
+  getNamespaceRoutes: () => getNamespaceRoutes,
+  getRoutes: () => getRoutes,
+  lockRouteRegistration: () => lockRouteRegistration,
+  registerRoute: () => registerRoute,
+  resolveRoute: () => resolveRoute,
+  route: () => route,
+  setServerLocation: () => setServerLocation,
+  unloadNamespace: () => unloadNamespace
+});
+
+// src/router/match.ts
+function match(path, pattern) {
+  const normalizedPath = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+  const normalizedPattern = pattern.endsWith("/") && pattern !== "/" ? pattern.slice(0, -1) : pattern;
+  const pathSegments = normalizedPath.split("/").filter(Boolean);
+  const patternSegments = normalizedPattern.split("/").filter(Boolean);
+  if (patternSegments.length === 1 && patternSegments[0] === "*") {
+    return {
+      matched: true,
+      params: {
+        "*": pathSegments.length > 1 ? normalizedPath : pathSegments[0]
+      }
+    };
+  }
+  if (pathSegments.length !== patternSegments.length) {
+    return { matched: false, params: {} };
+  }
+  const params = {};
+  for (let i = 0; i < patternSegments.length; i++) {
+    const patternSegment = patternSegments[i];
+    const pathSegment = pathSegments[i];
+    if (patternSegment.startsWith("{") && patternSegment.endsWith("}")) {
+      const paramName = patternSegment.slice(1, -1);
+      params[paramName] = decodeURIComponent(pathSegment);
+    } else if (patternSegment === "*") {
+      params["*"] = pathSegment;
+    } else if (patternSegment !== pathSegment) {
+      return { matched: false, params: {} };
+    }
+  }
+  return { matched: true, params };
+}
 
 // src/dev/invariant.ts
 function invariant(condition, message, context) {
@@ -17,11 +66,6 @@ function invariant(condition, message, context) {
 function assertSchedulingPrecondition(condition, violationMessage) {
   invariant(condition, `[Scheduler Precondition] ${violationMessage}`);
 }
-var init_invariant = __esm({
-  "src/dev/invariant.ts"() {
-    "use strict";
-  }
-});
 
 // src/dev/logger.ts
 function callConsole(method, args) {
@@ -35,31 +79,26 @@ function callConsole(method, args) {
     }
   }
 }
-var logger;
-var init_logger = __esm({
-  "src/dev/logger.ts"() {
-    "use strict";
-    logger = {
-      debug: (...args) => {
-        if (process.env.NODE_ENV === "production") return;
-        callConsole("debug", args);
-      },
-      info: (...args) => {
-        if (process.env.NODE_ENV === "production") return;
-        callConsole("info", args);
-      },
-      warn: (...args) => {
-        if (process.env.NODE_ENV === "production") return;
-        callConsole("warn", args);
-      },
-      error: (...args) => {
-        callConsole("error", args);
-      }
-    };
+var logger = {
+  debug: (...args) => {
+    if (process.env.NODE_ENV === "production") return;
+    callConsole("debug", args);
+  },
+  info: (...args) => {
+    if (process.env.NODE_ENV === "production") return;
+    callConsole("info", args);
+  },
+  warn: (...args) => {
+    if (process.env.NODE_ENV === "production") return;
+    callConsole("warn", args);
+  },
+  error: (...args) => {
+    callConsole("error", args);
   }
-});
+};
 
 // src/runtime/scheduler.ts
+var MAX_FLUSH_DEPTH = 50;
 function isBulkCommitActive() {
   try {
     const fb = globalThis.__ASKR_FASTLANE;
@@ -69,6 +108,250 @@ function isBulkCommitActive() {
     return false;
   }
 }
+var Scheduler = class {
+  constructor() {
+    this.q = [];
+    this.head = 0;
+    this.running = false;
+    this.inHandler = false;
+    this.depth = 0;
+    this.executionDepth = 0;
+    // for compat with existing diagnostics
+    // Monotonic flush version increments at end of each flush
+    this.flushVersion = 0;
+    // Best-effort microtask kick scheduling
+    this.kickScheduled = false;
+    // Escape hatch flag for runWithSyncProgress
+    this.allowSyncProgress = false;
+    // Waiters waiting for flushVersion >= target
+    this.waiters = [];
+    // Keep a lightweight taskCount for compatibility/diagnostics
+    this.taskCount = 0;
+  }
+  enqueue(task) {
+    assertSchedulingPrecondition(
+      typeof task === "function",
+      "enqueue() requires a function"
+    );
+    if (isBulkCommitActive() && !this.allowSyncProgress) {
+      if (process.env.NODE_ENV !== "production") {
+        throw new Error(
+          "[Scheduler] enqueue() during bulk commit (not allowed)"
+        );
+      }
+      return;
+    }
+    this.q.push(task);
+    this.taskCount++;
+    if (!this.running && !this.kickScheduled && !this.inHandler && !isBulkCommitActive()) {
+      this.kickScheduled = true;
+      queueMicrotask(() => {
+        this.kickScheduled = false;
+        if (this.running) return;
+        if (isBulkCommitActive()) return;
+        try {
+          this.flush();
+        } catch (err) {
+          setTimeout(() => {
+            throw err;
+          });
+        }
+      });
+    }
+  }
+  flush() {
+    invariant(
+      !this.running,
+      "[Scheduler] flush() called while already running"
+    );
+    if (process.env.NODE_ENV !== "production") {
+      if (isBulkCommitActive() && !this.allowSyncProgress) {
+        throw new Error(
+          "[Scheduler] flush() started during bulk commit (not allowed)"
+        );
+      }
+    }
+    this.running = true;
+    this.depth = 0;
+    let fatal = null;
+    try {
+      while (this.head < this.q.length) {
+        this.depth++;
+        if (process.env.NODE_ENV !== "production" && this.depth > MAX_FLUSH_DEPTH) {
+          throw new Error(
+            `[Scheduler] exceeded MAX_FLUSH_DEPTH (${MAX_FLUSH_DEPTH}). Likely infinite update loop.`
+          );
+        }
+        const task = this.q[this.head++];
+        try {
+          this.executionDepth++;
+          task();
+          this.executionDepth--;
+        } catch (err) {
+          if (this.executionDepth > 0) this.executionDepth = 0;
+          fatal = err;
+          break;
+        }
+        if (this.taskCount > 0) this.taskCount--;
+      }
+    } finally {
+      this.running = false;
+      this.depth = 0;
+      this.executionDepth = 0;
+      if (this.head >= this.q.length) {
+        this.q.length = 0;
+        this.head = 0;
+      } else if (this.head > 0) {
+        const remaining = this.q.length - this.head;
+        if (this.head > 1024 || this.head > remaining) {
+          this.q = this.q.slice(this.head);
+        } else {
+          for (let i = 0; i < remaining; i++) {
+            this.q[i] = this.q[this.head + i];
+          }
+          this.q.length = remaining;
+        }
+        this.head = 0;
+      }
+      this.flushVersion++;
+      this.resolveWaiters();
+    }
+    if (fatal) throw fatal;
+  }
+  runWithSyncProgress(fn) {
+    const prev = this.allowSyncProgress;
+    this.allowSyncProgress = true;
+    const g = globalThis;
+    const origQueueMicrotask = g.queueMicrotask;
+    const origSetTimeout = g.setTimeout;
+    if (process.env.NODE_ENV !== "production") {
+      g.queueMicrotask = () => {
+        throw new Error(
+          "[Scheduler] queueMicrotask not allowed during runWithSyncProgress"
+        );
+      };
+      g.setTimeout = () => {
+        throw new Error(
+          "[Scheduler] setTimeout not allowed during runWithSyncProgress"
+        );
+      };
+    }
+    const startVersion = this.flushVersion;
+    try {
+      const res = fn();
+      if (!this.running && this.q.length - this.head > 0) {
+        this.flush();
+      }
+      if (process.env.NODE_ENV !== "production") {
+        if (this.q.length - this.head > 0) {
+          throw new Error(
+            "[Scheduler] tasks remain after runWithSyncProgress flush"
+          );
+        }
+      }
+      return res;
+    } finally {
+      if (process.env.NODE_ENV !== "production") {
+        g.queueMicrotask = origQueueMicrotask;
+        g.setTimeout = origSetTimeout;
+      }
+      try {
+        if (this.flushVersion === startVersion) {
+          this.flushVersion++;
+          this.resolveWaiters();
+        }
+      } catch (e) {
+        void e;
+      }
+      this.allowSyncProgress = prev;
+    }
+  }
+  waitForFlush(targetVersion, timeoutMs = 2e3) {
+    const target = typeof targetVersion === "number" ? targetVersion : this.flushVersion + 1;
+    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(),
+          namespace: ns
+        };
+        reject(
+          new Error(
+            `waitForFlush timeout ${timeoutMs}ms: ${JSON.stringify(diag)}`
+          )
+        );
+      }, timeoutMs);
+      this.waiters.push({ target, resolve, reject, timer });
+    });
+  }
+  getState() {
+    return {
+      queueLength: this.q.length - this.head,
+      running: this.running,
+      depth: this.depth,
+      executionDepth: this.executionDepth,
+      taskCount: this.taskCount,
+      flushVersion: this.flushVersion,
+      // New fields for optional inspection
+      inHandler: this.inHandler,
+      allowSyncProgress: this.allowSyncProgress
+    };
+  }
+  setInHandler(v) {
+    this.inHandler = v;
+  }
+  isInHandler() {
+    return this.inHandler;
+  }
+  isExecuting() {
+    return this.running || this.executionDepth > 0;
+  }
+  // Clear pending synchronous tasks (used by fastlane enter/exit)
+  clearPendingSyncTasks() {
+    const remaining = this.q.length - this.head;
+    if (remaining <= 0) return 0;
+    if (this.running) {
+      this.q.length = this.head;
+      this.taskCount = Math.max(0, this.taskCount - remaining);
+      queueMicrotask(() => {
+        try {
+          this.flushVersion++;
+          this.resolveWaiters();
+        } catch (e) {
+          void e;
+        }
+      });
+      return remaining;
+    }
+    this.q.length = 0;
+    this.head = 0;
+    this.taskCount = Math.max(0, this.taskCount - remaining);
+    this.flushVersion++;
+    this.resolveWaiters();
+    return remaining;
+  }
+  resolveWaiters() {
+    if (this.waiters.length === 0) return;
+    const ready = [];
+    const remaining = [];
+    for (const w of this.waiters) {
+      if (this.flushVersion >= w.target) {
+        if (w.timer) clearTimeout(w.timer);
+        ready.push(w.resolve);
+      } else {
+        remaining.push(w);
+      }
+    }
+    this.waiters = remaining;
+    for (const r of ready) r();
+  }
+};
+var globalScheduler = new Scheduler();
 function isSchedulerExecuting() {
   return globalScheduler.isExecuting();
 }
@@ -96,261 +379,11 @@ function scheduleEventHandler(handler) {
     }
   };
 }
-var MAX_FLUSH_DEPTH, Scheduler, globalScheduler;
-var init_scheduler = __esm({
-  "src/runtime/scheduler.ts"() {
-    "use strict";
-    init_invariant();
-    init_logger();
-    MAX_FLUSH_DEPTH = 50;
-    Scheduler = class {
-      constructor() {
-        this.q = [];
-        this.head = 0;
-        this.running = false;
-        this.inHandler = false;
-        this.depth = 0;
-        this.executionDepth = 0;
-        // for compat with existing diagnostics
-        // Monotonic flush version increments at end of each flush
-        this.flushVersion = 0;
-        // Best-effort microtask kick scheduling
-        this.kickScheduled = false;
-        // Escape hatch flag for runWithSyncProgress
-        this.allowSyncProgress = false;
-        // Waiters waiting for flushVersion >= target
-        this.waiters = [];
-        // Keep a lightweight taskCount for compatibility/diagnostics
-        this.taskCount = 0;
-      }
-      enqueue(task) {
-        assertSchedulingPrecondition(
-          typeof task === "function",
-          "enqueue() requires a function"
-        );
-        if (isBulkCommitActive() && !this.allowSyncProgress) {
-          if (process.env.NODE_ENV !== "production") {
-            throw new Error(
-              "[Scheduler] enqueue() during bulk commit (not allowed)"
-            );
-          }
-          return;
-        }
-        this.q.push(task);
-        this.taskCount++;
-        if (!this.running && !this.kickScheduled && !this.inHandler && !isBulkCommitActive()) {
-          this.kickScheduled = true;
-          queueMicrotask(() => {
-            this.kickScheduled = false;
-            if (this.running) return;
-            if (isBulkCommitActive()) return;
-            try {
-              this.flush();
-            } catch (err) {
-              setTimeout(() => {
-                throw err;
-              });
-            }
-          });
-        }
-      }
-      flush() {
-        invariant(
-          !this.running,
-          "[Scheduler] flush() called while already running"
-        );
-        if (process.env.NODE_ENV !== "production") {
-          if (isBulkCommitActive() && !this.allowSyncProgress) {
-            throw new Error(
-              "[Scheduler] flush() started during bulk commit (not allowed)"
-            );
-          }
-        }
-        this.running = true;
-        this.depth = 0;
-        let fatal = null;
-        try {
-          while (this.head < this.q.length) {
-            this.depth++;
-            if (process.env.NODE_ENV !== "production" && this.depth > MAX_FLUSH_DEPTH) {
-              throw new Error(
-                `[Scheduler] exceeded MAX_FLUSH_DEPTH (${MAX_FLUSH_DEPTH}). Likely infinite update loop.`
-              );
-            }
-            const task = this.q[this.head++];
-            try {
-              this.executionDepth++;
-              task();
-              this.executionDepth--;
-            } catch (err) {
-              if (this.executionDepth > 0) this.executionDepth = 0;
-              fatal = err;
-              break;
-            }
-            if (this.taskCount > 0) this.taskCount--;
-          }
-        } finally {
-          this.running = false;
-          this.depth = 0;
-          this.executionDepth = 0;
-          if (this.head >= this.q.length) {
-            this.q.length = 0;
-            this.head = 0;
-          } else if (this.head > 0) {
-            const remaining = this.q.length - this.head;
-            if (this.head > 1024 || this.head > remaining) {
-              this.q = this.q.slice(this.head);
-            } else {
-              for (let i = 0; i < remaining; i++) {
-                this.q[i] = this.q[this.head + i];
-              }
-              this.q.length = remaining;
-            }
-            this.head = 0;
-          }
-          this.flushVersion++;
-          this.resolveWaiters();
-        }
-        if (fatal) throw fatal;
-      }
-      runWithSyncProgress(fn) {
-        const prev = this.allowSyncProgress;
-        this.allowSyncProgress = true;
-        const g = globalThis;
-        const origQueueMicrotask = g.queueMicrotask;
-        const origSetTimeout = g.setTimeout;
-        if (process.env.NODE_ENV !== "production") {
-          g.queueMicrotask = () => {
-            throw new Error(
-              "[Scheduler] queueMicrotask not allowed during runWithSyncProgress"
-            );
-          };
-          g.setTimeout = () => {
-            throw new Error(
-              "[Scheduler] setTimeout not allowed during runWithSyncProgress"
-            );
-          };
-        }
-        const startVersion = this.flushVersion;
-        try {
-          const res = fn();
-          if (!this.running && this.q.length - this.head > 0) {
-            this.flush();
-          }
-          if (process.env.NODE_ENV !== "production") {
-            if (this.q.length - this.head > 0) {
-              throw new Error(
-                "[Scheduler] tasks remain after runWithSyncProgress flush"
-              );
-            }
-          }
-          return res;
-        } finally {
-          if (process.env.NODE_ENV !== "production") {
-            g.queueMicrotask = origQueueMicrotask;
-            g.setTimeout = origSetTimeout;
-          }
-          try {
-            if (this.flushVersion === startVersion) {
-              this.flushVersion++;
-              this.resolveWaiters();
-            }
-          } catch (e) {
-            void e;
-          }
-          this.allowSyncProgress = prev;
-        }
-      }
-      waitForFlush(targetVersion, timeoutMs = 2e3) {
-        const target = typeof targetVersion === "number" ? targetVersion : this.flushVersion + 1;
-        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(),
-              namespace: ns
-            };
-            reject(
-              new Error(
-                `waitForFlush timeout ${timeoutMs}ms: ${JSON.stringify(diag)}`
-              )
-            );
-          }, timeoutMs);
-          this.waiters.push({ target, resolve, reject, timer });
-        });
-      }
-      getState() {
-        return {
-          queueLength: this.q.length - this.head,
-          running: this.running,
-          depth: this.depth,
-          executionDepth: this.executionDepth,
-          taskCount: this.taskCount,
-          flushVersion: this.flushVersion,
-          // New fields for optional inspection
-          inHandler: this.inHandler,
-          allowSyncProgress: this.allowSyncProgress
-        };
-      }
-      setInHandler(v) {
-        this.inHandler = v;
-      }
-      isInHandler() {
-        return this.inHandler;
-      }
-      isExecuting() {
-        return this.running || this.executionDepth > 0;
-      }
-      // Clear pending synchronous tasks (used by fastlane enter/exit)
-      clearPendingSyncTasks() {
-        const remaining = this.q.length - this.head;
-        if (remaining <= 0) return 0;
-        if (this.running) {
-          this.q.length = this.head;
-          this.taskCount = Math.max(0, this.taskCount - remaining);
-          queueMicrotask(() => {
-            try {
-              this.flushVersion++;
-              this.resolveWaiters();
-            } catch (e) {
-              void e;
-            }
-          });
-          return remaining;
-        }
-        this.q.length = 0;
-        this.head = 0;
-        this.taskCount = Math.max(0, this.taskCount - remaining);
-        this.flushVersion++;
-        this.resolveWaiters();
-        return remaining;
-      }
-      resolveWaiters() {
-        if (this.waiters.length === 0) return;
-        const ready = [];
-        const remaining = [];
-        for (const w of this.waiters) {
-          if (this.flushVersion >= w.target) {
-            if (w.timer) clearTimeout(w.timer);
-            ready.push(w.resolve);
-          } else {
-            remaining.push(w);
-          }
-        }
-        this.waiters = remaining;
-        for (const r of ready) r();
-      }
-    };
-    globalScheduler = new Scheduler();
-  }
-});
 
 // src/runtime/context.ts
+var CONTEXT_FRAME_SYMBOL = /* @__PURE__ */ Symbol("__tempoContextFrame__");
+var currentContextFrame = null;
+var currentAsyncResourceFrame = null;
 function withContext(frame, fn) {
   const oldFrame = currentContextFrame;
   currentContextFrame = frame;
@@ -469,16 +502,6 @@ function ContextFunctionChildInvoker(props) {
 function getCurrentContextFrame() {
   return currentContextFrame;
 }
-var CONTEXT_FRAME_SYMBOL, currentContextFrame, currentAsyncResourceFrame;
-var init_context = __esm({
-  "src/runtime/context.ts"() {
-    "use strict";
-    init_component();
-    CONTEXT_FRAME_SYMBOL = /* @__PURE__ */ Symbol("__tempoContextFrame__");
-    currentContextFrame = null;
-    currentAsyncResourceFrame = null;
-  }
-});
 
 // src/renderer/diag/index.ts
 function getDiagMap() {
@@ -536,13 +559,51 @@ function __ASKR_incCounter(key) {
     void e;
   }
 }
-var init_diag = __esm({
-  "src/renderer/diag/index.ts"() {
-    "use strict";
+
+// src/runtime/dev-namespace.ts
+function getDevNamespace() {
+  if (process.env.NODE_ENV === "production") return {};
+  try {
+    const g = globalThis;
+    if (!g.__ASKR__) g.__ASKR__ = {};
+    return g.__ASKR__;
+  } catch {
+    return {};
   }
-});
+}
+function setDevValue(key, value) {
+  if (process.env.NODE_ENV === "production") return;
+  try {
+    getDevNamespace()[key] = value;
+  } catch {
+  }
+}
+function getDevValue(key) {
+  if (process.env.NODE_ENV === "production") return void 0;
+  try {
+    return getDevNamespace()[key];
+  } catch {
+    return void 0;
+  }
+}
 
 // src/runtime/fastlane-shared.ts
+var _bulkCommitActive = false;
+var _appliedParents = null;
+function enterBulkCommit() {
+  _bulkCommitActive = true;
+  _appliedParents = /* @__PURE__ */ new WeakSet();
+  try {
+    const cleared = globalScheduler.clearPendingSyncTasks?.() ?? 0;
+    setDevValue("__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;
 }
@@ -554,95 +615,62 @@ function markFastPathApplied(parent) {
     void e;
   }
 }
-var _bulkCommitActive, _appliedParents;
-var init_fastlane_shared = __esm({
-  "src/runtime/fastlane-shared.ts"() {
-    "use strict";
-    _bulkCommitActive = false;
-    _appliedParents = null;
-  }
-});
+function isFastPathApplied(parent) {
+  return !!(_appliedParents && _appliedParents.has(parent));
+}
 
 // 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 = [];
+function cleanupSingleInstance(node, errors, strict) {
+  const inst = node.__ASKR_INSTANCE;
+  if (!inst) return;
   try {
-    const inst = node.__ASKR_INSTANCE;
-    if (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) {
-        if (opts?.strict) errors.push(e);
-        else void e;
-      }
-    }
+    cleanupComponent(inst);
   } catch (err) {
-    if (opts?.strict) errors.push(err);
-    else if (process.env.NODE_ENV !== "production") {
-      logger.warn("[Askr] cleanupInstanceIfPresent failed:", err);
-    }
+    if (strict) errors.push(err);
+    else logger.warn("[Askr] cleanupComponent failed:", err);
+  }
+  try {
+    delete node.__ASKR_INSTANCE;
+  } catch (e) {
+    if (strict) errors.push(e);
+  }
+}
+function cleanupInstanceIfPresent(node, opts) {
+  if (!node || !(node instanceof Element)) return;
+  const errors = [];
+  const strict = opts?.strict ?? false;
+  try {
+    cleanupSingleInstance(node, errors, strict);
+  } catch (err) {
+    if (strict) errors.push(err);
+    else logger.warn("[Askr] cleanupInstanceIfPresent failed:", err);
   }
   try {
     const descendants = node.querySelectorAll("*");
     for (const d of Array.from(descendants)) {
       try {
-        const inst = d.__ASKR_INSTANCE;
-        if (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) {
-            if (opts?.strict) errors.push(e);
-            else void e;
-          }
-        }
+        cleanupSingleInstance(d, errors, strict);
       } catch (err) {
-        if (opts?.strict) errors.push(err);
-        else if (process.env.NODE_ENV !== "production") {
+        if (strict) errors.push(err);
+        else
           logger.warn(
             "[Askr] cleanupInstanceIfPresent descendant cleanup failed:",
             err
           );
-        }
       }
     }
   } catch (err) {
-    if (opts?.strict) errors.push(err);
-    else if (process.env.NODE_ENV !== "production") {
+    if (strict) errors.push(err);
+    else
       logger.warn(
         "[Askr] cleanupInstanceIfPresent descendant query failed:",
         err
       );
-    }
   }
   if (errors.length > 0) {
     throw new AggregateError(errors, "cleanupInstanceIfPresent failed");
@@ -651,6 +679,7 @@ function cleanupInstanceIfPresent(node, opts) {
 function cleanupInstancesUnder(node, opts) {
   cleanupInstanceIfPresent(node, opts);
 }
+var elementListeners = /* @__PURE__ */ new WeakMap();
 function removeElementListeners(element) {
   const map = elementListeners.get(element);
   if (map) {
@@ -670,34 +699,217 @@ function removeAllListeners(root) {
     removeElementListeners(children[i]);
   }
 }
-var elementListeners;
-var init_cleanup = __esm({
-  "src/renderer/cleanup.ts"() {
-    "use strict";
-    init_component();
-    init_logger();
-    elementListeners = /* @__PURE__ */ new WeakMap();
+
+// src/renderer/utils.ts
+function parseEventName(propName) {
+  if (!propName.startsWith("on") || propName.length <= 2) return null;
+  return propName.slice(2).charAt(0).toLowerCase() + propName.slice(3).toLowerCase();
+}
+function getPassiveOptions(eventName) {
+  if (eventName === "wheel" || eventName === "scroll" || eventName.startsWith("touch")) {
+    return { passive: true };
   }
-});
+  return void 0;
+}
+function createWrappedHandler(handler, flushAfter = false) {
+  return (event) => {
+    globalScheduler.setInHandler(true);
+    try {
+      handler(event);
+    } catch (error) {
+      logger.error("[Askr] Event handler error:", error);
+    } finally {
+      globalScheduler.setInHandler(false);
+      if (flushAfter) {
+        const state = globalScheduler.getState();
+        if ((state.queueLength ?? 0) > 0 && !state.running) {
+          queueMicrotask(() => {
+            try {
+              if (!globalScheduler.isExecuting()) globalScheduler.flush();
+            } catch (err) {
+              queueMicrotask(() => {
+                throw err;
+              });
+            }
+          });
+        }
+      }
+    }
+  };
+}
+function isSkippedProp(key) {
+  return key === "children" || key === "key";
+}
+function isIgnoredForPropChanges(key) {
+  if (key === "children" || key === "key") return true;
+  if (key.startsWith("on") && key.length > 2) return true;
+  if (key.startsWith("data-")) return true;
+  return false;
+}
+function hasPropChanged(el, key, value) {
+  try {
+    if (key === "class" || key === "className") {
+      return el.className !== String(value);
+    }
+    if (key === "value" || key === "checked") {
+      return el[key] !== value;
+    }
+    const attr = el.getAttribute(key);
+    if (value === void 0 || value === null || value === false) {
+      return attr !== null;
+    }
+    return String(value) !== attr;
+  } catch {
+    return true;
+  }
+}
+function hasNonTrivialProps(props) {
+  for (const k of Object.keys(props)) {
+    if (isIgnoredForPropChanges(k)) continue;
+    return true;
+  }
+  return false;
+}
+function checkPropChanges(el, props) {
+  for (const k of Object.keys(props)) {
+    if (isIgnoredForPropChanges(k)) continue;
+    if (hasPropChanged(el, k, props[k])) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractKey(vnode) {
+  if (typeof vnode !== "object" || vnode === null) return void 0;
+  const obj = vnode;
+  const rawKey = obj.key ?? obj.props?.key;
+  if (rawKey === void 0) return void 0;
+  return typeof rawKey === "symbol" ? String(rawKey) : rawKey;
+}
+function buildKeyMapFromChildren(parent) {
+  const map = /* @__PURE__ */ new Map();
+  const children = Array.from(parent.children);
+  for (const ch of children) {
+    const k = ch.getAttribute("data-key");
+    if (k !== null) {
+      map.set(k, ch);
+      const n = Number(k);
+      if (!Number.isNaN(n)) map.set(n, ch);
+    }
+  }
+  return map;
+}
+function recordDOMReplace(source) {
+  try {
+    __ASKR_incCounter("__DOM_REPLACE_COUNT");
+    __ASKR_set(`__LAST_DOM_REPLACE_STACK_${source}`, new Error().stack);
+  } catch {
+  }
+}
+function recordFastPathStats(stats, counterName) {
+  try {
+    __ASKR_set("__LAST_FASTPATH_STATS", stats);
+    __ASKR_set("__LAST_FASTPATH_COMMIT_COUNT", 1);
+    if (counterName) {
+      __ASKR_incCounter(counterName);
+    }
+  } catch {
+  }
+}
+function logFastPathDebug(message, indexOrData, data) {
+  if (process.env.ASKR_FASTPATH_DEBUG === "1" || process.env.ASKR_FASTPATH_DEBUG === "true") {
+    if (data !== void 0) {
+      logger.warn(`[Askr][FASTPATH] ${message}`, indexOrData, data);
+    } else if (indexOrData !== void 0) {
+      logger.warn(`[Askr][FASTPATH] ${message}`, indexOrData);
+    } else {
+      logger.warn(`[Askr][FASTPATH] ${message}`);
+    }
+  }
+}
+function now() {
+  return typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+}
 
 // src/renderer/keyed.ts
+var keyedElements = /* @__PURE__ */ new WeakMap();
 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
-        });
+function populateKeyMapForElement(parent) {
+  try {
+    if (keyedElements.has(parent)) return;
+    let domMap = buildKeyMapFromChildren(parent);
+    if (domMap.size === 0) {
+      domMap = /* @__PURE__ */ new Map();
+      const children = Array.from(parent.children);
+      for (const ch of children) {
+        const text = (ch.textContent || "").trim();
+        if (text) {
+          domMap.set(text, ch);
+          const n = Number(text);
+          if (!Number.isNaN(n)) domMap.set(n, ch);
+        }
+      }
+    }
+    if (domMap.size > 0) keyedElements.set(parent, domMap);
+  } catch {
+  }
+}
+var _reconcilerRecordedParents = /* @__PURE__ */ new WeakSet();
+function extractKeyedVnodes(newChildren) {
+  const result = [];
+  for (const child of newChildren) {
+    const key = extractKey(child);
+    if (key !== void 0) {
+      result.push({ key, vnode: child });
+    }
+  }
+  return result;
+}
+function computeLISLength(positions) {
+  const tails = [];
+  for (const pos of positions) {
+    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);
+    else tails[lo] = pos;
+  }
+  return tails.length;
+}
+function checkVnodesHaveProps(keyedVnodes) {
+  for (const { vnode } of keyedVnodes) {
+    if (typeof vnode !== "object" || vnode === null) continue;
+    const vnodeObj = vnode;
+    if (vnodeObj.props && hasNonTrivialProps(vnodeObj.props)) {
+      return true;
+    }
+  }
+  return false;
+}
+function checkVnodePropChanges(keyedVnodes, oldKeyMap) {
+  for (const { key, vnode } of keyedVnodes) {
+    const el = oldKeyMap?.get(key);
+    if (!el || typeof vnode !== "object" || vnode === null) continue;
+    const vnodeObj = vnode;
+    const props = vnodeObj.props || {};
+    for (const k of Object.keys(props)) {
+      if (isIgnoredForPropChanges(k)) continue;
+      if (hasPropChanged(el, k, props[k])) {
+        return true;
       }
     }
   }
+  return false;
+}
+function isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap) {
+  const keyedVnodes = extractKeyedVnodes(newChildren);
   const totalKeyed = keyedVnodes.length;
   const newKeyOrder = keyedVnodes.map((kv) => kv.key);
   const oldKeyOrder = oldKeyMap ? Array.from(oldKeyMap.keys()) : [];
@@ -718,89 +930,15 @@ function isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap) {
   let lisLen = 0;
   if (totalKeyed >= 128) {
     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 positions = keyedVnodes.map(({ key }) => {
       const el = oldKeyMap?.get(key);
-      if (el && el.parentElement === parent) {
-        positions[i] = parentChildren.indexOf(el);
-      }
-    }
-    const tails = [];
-    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);
-      else tails[lo] = pos;
-    }
-    lisLen = tails.length;
+      return el?.parentElement === parent ? parentChildren.indexOf(el) : -1;
+    });
+    lisLen = computeLISLength(positions);
     lisTrigger = lisLen < Math.floor(totalKeyed * 0.5);
   }
-  let hasPropsPresent = false;
-  for (let i = 0; i < keyedVnodes.length; i++) {
-    const vnode = keyedVnodes[i].vnode;
-    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;
-      if (k.startsWith("data-")) continue;
-      hasPropsPresent = true;
-      break;
-    }
-    if (hasPropsPresent) break;
-  }
-  let hasPropChanges = false;
-  for (let i = 0; i < keyedVnodes.length; i++) {
-    const { key, vnode } = keyedVnodes[i];
-    const el = oldKeyMap?.get(key);
-    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;
-      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;
-  }
+  const hasPropsPresent = checkVnodesHaveProps(keyedVnodes);
+  const hasPropChanges = checkVnodePropChanges(keyedVnodes, oldKeyMap);
   const useFastPath = (cheapMoveTrigger || lisTrigger) && !hasPropChanges && !hasPropsPresent;
   return {
     useFastPath,
@@ -810,23 +948,103 @@ function isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap) {
     hasPropChanges
   };
 }
-var keyedElements, _reconcilerRecordedParents;
-var init_keyed = __esm({
-  "src/renderer/keyed.ts"() {
-    "use strict";
-    keyedElements = /* @__PURE__ */ new WeakMap();
-    _reconcilerRecordedParents = /* @__PURE__ */ new WeakSet();
-  }
-});
 
 // src/renderer/dom.ts
+var IS_DOM_AVAILABLE = typeof document !== "undefined";
+function addTrackedListener(el, eventName, handler) {
+  const wrappedHandler = createWrappedHandler(handler, true);
+  const options = getPassiveOptions(eventName);
+  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: handler,
+    options
+  });
+}
+function applyPropsToElement(el, props, tagName) {
+  for (const key in props) {
+    const value = props[key];
+    if (isSkippedProp(key)) continue;
+    if (value === void 0 || value === null || value === false) continue;
+    const eventName = parseEventName(key);
+    if (eventName) {
+      addTrackedListener(el, eventName, value);
+      continue;
+    }
+    if (key === "class" || key === "className") {
+      el.className = String(value);
+    } else if (key === "value" || key === "checked") {
+      applyFormControlProp(el, key, value, tagName);
+    } else {
+      el.setAttribute(key, String(value));
+    }
+  }
+}
+function applyFormControlProp(el, key, value, tagName) {
+  const tag = tagName.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));
+    }
+  } else if (key === "checked") {
+    if (tag === "input") {
+      el.checked = Boolean(value);
+      el.setAttribute("checked", String(Boolean(value)));
+    } else {
+      el.setAttribute("checked", String(Boolean(value)));
+    }
+  }
+}
+function materializeKey(el, vnode, props) {
+  const vnodeKey = vnode.key ?? props?.key;
+  if (vnodeKey !== void 0) {
+    el.setAttribute("data-key", String(vnodeKey));
+  }
+}
+function warnMissingKeys(children) {
+  if (process.env.NODE_ENV === "production") return;
+  let hasElements = false;
+  let hasKeys = false;
+  for (const item of children) {
+    if (typeof item === "object" && item !== null && "type" in item) {
+      hasElements = true;
+      const rawKey = item.key ?? item.props?.key;
+      if (rawKey !== void 0) {
+        hasKeys = true;
+        break;
+      }
+    }
+  }
+  if (hasElements && !hasKeys) {
+    try {
+      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 {
+      logger.warn(
+        'Missing keys on dynamic lists. Each child in a list should have a unique "key" prop.'
+      );
+    }
+  }
+}
 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 {
       }
     }
     return null;
@@ -842,8 +1060,8 @@ function createDOMNode(node) {
   }
   if (Array.isArray(node)) {
     const fragment = document.createDocumentFragment();
-    for (let i = 0; i < node.length; i++) {
-      const dom = createDOMNode(node[i]);
+    for (const child of node) {
+      const dom = createDOMNode(child);
       if (dom) fragment.appendChild(dom);
     }
     return fragment;
@@ -852,212 +1070,124 @@ function createDOMNode(node) {
     const type = node.type;
     const props = node.props || {};
     if (typeof type === "string") {
-      const el = document.createElement(type);
-      for (const key in props) {
-        const value = props[key];
-        if (key === "children" || key === "key") continue;
-        if (value === void 0 || value === null || value === false) continue;
-        if (key.startsWith("on") && key.length > 2) {
-          const eventName = key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();
-          const wrappedHandler = (event) => {
-            globalScheduler.setInHandler(true);
-            try {
-              value(event);
-            } catch (error) {
-              logger.error("[Askr] Event handler error:", error);
-            } finally {
-              globalScheduler.setInHandler(false);
-              const state = globalScheduler.getState();
-              if ((state.queueLength ?? 0) > 0 && !state.running) {
-                queueMicrotask(() => {
-                  try {
-                    if (!globalScheduler.isExecuting()) globalScheduler.flush();
-                  } catch (err) {
-                    queueMicrotask(() => {
-                      throw err;
-                    });
-                  }
-                });
-              }
-            }
-          };
-          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 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));
-            }
-          } else {
-            if (tag === "input") {
-              el.checked = Boolean(value);
-              el.setAttribute("checked", String(Boolean(value)));
-            } else {
-              el.setAttribute("checked", String(Boolean(value)));
-            }
-          }
-        } 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;
-                }
-              }
-            }
-            if (hasElements && !hasKeys) {
-              if (typeof console !== "undefined") {
-                try {
-                  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;
-                }
-              }
-            }
-          }
-          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);
-        }
-      }
-      return el;
+      return createIntrinsicElement(node, type, props);
     }
     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."
-        );
+      return createComponentElement(node, type, props);
+    }
+    if (typeof type === "symbol" && (type === Fragment2 || String(type) === "Symbol(Fragment)")) {
+      return createFragmentElement(node, props);
+    }
+  }
+  return null;
+}
+function createIntrinsicElement(node, type, props) {
+  const el = document.createElement(type);
+  materializeKey(el, node, props);
+  applyPropsToElement(el, props, type);
+  const children = props.children || node.children;
+  if (children) {
+    if (Array.isArray(children)) {
+      warnMissingKeys(children);
+      for (const child of children) {
+        const dom = createDOMNode(child);
+        if (dom) el.appendChild(dom);
       }
-      const dom = withContext(snapshot, () => createDOMNode(result));
-      if (dom instanceof Element) {
-        mountInstanceInline(childInstance, dom);
-        return dom;
-      }
-      const host = document.createElement("div");
-      if (dom instanceof DocumentFragment) {
-        host.appendChild(dom);
-      } else if (dom) {
-        host.appendChild(dom);
-      }
-      mountInstanceInline(childInstance, host);
-      return host;
-    }
-    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);
-        }
+    } else {
+      const dom = createDOMNode(children);
+      if (dom) el.appendChild(dom);
+    }
+  }
+  return el;
+}
+function createComponentElement(node, type, props) {
+  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."
+    );
+  }
+  let childInstance = node.__instance;
+  if (!childInstance) {
+    childInstance = createComponentInstance(
+      `comp-${Math.random().toString(36).slice(2, 7)}`,
+      componentFn,
+      props || {},
+      null
+    );
+    node.__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);
+    return dom;
+  }
+  if (!dom) {
+    const placeholder = document.createComment("");
+    childInstance._placeholder = placeholder;
+    childInstance.mounted = true;
+    childInstance.notifyUpdate = childInstance._enqueueRun;
+    return placeholder;
+  }
+  const host = document.createElement("div");
+  host.appendChild(dom);
+  mountInstanceInline(childInstance, host);
+  return host;
+}
+function createFragmentElement(node, props) {
+  const fragment = document.createDocumentFragment();
+  const children = props.children || node.children;
+  if (children) {
+    if (Array.isArray(children)) {
+      for (const child of children) {
+        const dom = createDOMNode(child);
+        if (dom) fragment.appendChild(dom);
       }
-      return fragment;
+    } else {
+      const dom = createDOMNode(children);
+      if (dom) fragment.appendChild(dom);
     }
   }
-  return null;
+  return fragment;
 }
 function updateElementFromVnode(el, vnode, updateChildren = true) {
   if (!_isDOMElement(vnode)) {
     return;
   }
   const props = vnode.props || {};
-  const vnodeKey = vnode.key ?? vnode.props?.key;
-  if (vnodeKey !== void 0) {
-    el.setAttribute("data-key", String(vnodeKey));
-  }
+  materializeKey(el, vnode, props);
   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 (isSkippedProp(key)) continue;
+    const eventName = parseEventName(key);
     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);
+      } else if (eventName && 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);
         }
-        continue;
+        existingListeners.delete(eventName);
       } else {
         el.removeAttribute(key);
       }
@@ -1067,8 +1197,7 @@ function updateElementFromVnode(el, vnode, updateChildren = true) {
       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();
+    } else if (eventName) {
       desiredEventNames.add(eventName);
       const existing = existingListeners?.get(eventName);
       if (existing && existing.original === value) {
@@ -1077,20 +1206,16 @@ function updateElementFromVnode(el, vnode, updateChildren = true) {
       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)
+      const wrappedHandler = createWrappedHandler(
+        value,
+        false
+      );
+      const options = getPassiveOptions(eventName);
+      if (options !== void 0) {
         el.addEventListener(eventName, wrappedHandler, options);
-      else el.addEventListener(eventName, wrappedHandler);
+      } else {
+        el.addEventListener(eventName, wrappedHandler);
+      }
       if (!elementListeners.has(el)) {
         elementListeners.set(el, /* @__PURE__ */ new Map());
       }
@@ -1105,8 +1230,8 @@ function updateElementFromVnode(el, vnode, updateChildren = true) {
   }
   if (existingListeners) {
     for (const eventName of existingListeners.keys()) {
-      const entry = existingListeners.get(eventName);
       if (!desiredEventNames.has(eventName)) {
+        const entry = existingListeners.get(eventName);
         el.removeEventListener(eventName, entry.handler);
         existingListeners.delete(eventName);
       }
@@ -1141,6 +1266,14 @@ function updateElementChildren(el, children) {
 }
 function updateUnkeyedChildren(parent, newChildren) {
   const existing = Array.from(parent.children);
+  if (newChildren.length === 1 && existing.length === 0 && parent.childNodes.length === 1) {
+    const firstNewChild = newChildren[0];
+    const firstExisting = parent.firstChild;
+    if ((typeof firstNewChild === "string" || typeof firstNewChild === "number") && firstExisting?.nodeType === 3) {
+      firstExisting.data = String(firstNewChild);
+      return;
+    }
+  }
   if (existing.length === 0 && parent.childNodes.length > 0) {
     parent.textContent = "";
   }
@@ -1195,7 +1328,7 @@ function performBulkPositionalKeyedTextUpdate(parent, keyedVnodes) {
   const total = keyedVnodes.length;
   let reused = 0;
   let updatedKeys = 0;
-  const t0 = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+  const t0 = now();
   for (let i = 0; i < total; i++) {
     const { key, vnode } = keyedVnodes[i];
     const ch = parent.children[i];
@@ -1203,202 +1336,209 @@ 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);
-          } else {
-            ch.textContent = String(children);
-          }
-        } else if (Array.isArray(children) && children.length === 1 && (typeof children[0] === "string" || typeof children[0] === "number")) {
-          if (ch.childNodes.length === 1 && ch.firstChild?.nodeType === 3) {
-            ch.firstChild.data = String(children[0]);
-          } else {
-            ch.textContent = String(children[0]);
-          }
-        } else {
-          updateElementFromVnode(ch, vnode);
-        }
-        try {
-          ch.setAttribute("data-key", String(key));
-          updatedKeys++;
-        } catch (e) {
-          void e;
-        }
+        logFastPathDebug("positional idx", i, {
+          chTag: ch.tagName.toLowerCase(),
+          vnodeType,
+          chChildNodes: ch.childNodes.length,
+          childrenType: Array.isArray(children) ? "array" : typeof children
+        });
+        updateTextContent(ch, children);
+        setDataKey(ch, key, () => updatedKeys++);
         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;
-        }
+        logFastPathDebug("positional tag mismatch", i, {
+          chTag: ch.tagName.toLowerCase(),
+          vnodeType
+        });
       }
     } 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;
-      }
+      logFastPathDebug("positional missing or invalid", i, { ch: !!ch });
     }
-    const dom = createDOMNode(vnode);
-    if (dom) {
-      const existing = parent.children[i];
-      if (existing) {
-        cleanupInstanceIfPresent(existing);
-        parent.replaceChild(dom, existing);
-      } else parent.appendChild(dom);
+    replaceNodeAtPosition(parent, i, vnode);
+  }
+  const t = now() - t0;
+  updateKeyedElementsMap(parent, keyedVnodes);
+  const stats = { n: total, reused, updatedKeys, t };
+  recordFastPathStats(stats, "bulkKeyedPositionalHits");
+  return stats;
+}
+function updateTextContent(el, children) {
+  if (typeof children === "string" || typeof children === "number") {
+    setTextNodeData(el, String(children));
+  } else if (Array.isArray(children) && children.length === 1 && (typeof children[0] === "string" || typeof children[0] === "number")) {
+    setTextNodeData(el, String(children[0]));
+  } else {
+    updateElementFromVnode(el, el);
+  }
+}
+function setTextNodeData(el, text) {
+  if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
+    el.firstChild.data = text;
+  } else {
+    el.textContent = text;
+  }
+}
+function setDataKey(el, key, onSet) {
+  try {
+    el.setAttribute("data-key", String(key));
+    onSet();
+  } catch {
+  }
+}
+function replaceNodeAtPosition(parent, index, vnode) {
+  const dom = createDOMNode(vnode);
+  if (dom) {
+    const existing = parent.children[index];
+    if (existing) {
+      cleanupInstanceIfPresent(existing);
+      parent.replaceChild(dom, existing);
+    } else {
+      parent.appendChild(dom);
     }
   }
-  const t = typeof performance !== "undefined" && performance.now ? performance.now() - t0 : 0;
+}
+function updateKeyedElementsMap(parent, keyedVnodes) {
   try {
     const newKeyMap = /* @__PURE__ */ new Map();
-    for (let i = 0; i < total; i++) {
+    for (let i = 0; i < keyedVnodes.length; i++) {
       const k = keyedVnodes[i].key;
       const ch = parent.children[i];
       if (ch) newKeyMap.set(k, ch);
     }
     keyedElements.set(parent, newKeyMap);
-  } 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;
+  } catch {
   }
-  return stats;
 }
 function performBulkTextReplace(parent, newChildren) {
-  const t0 = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+  const t0 = 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 result = processChildNode(newChildren[i], existing[i], finalNodes);
+    if (result === "reused") reused++;
+    else if (result === "created") created++;
+  }
+  const tBuild = now() - t0;
+  cleanupRemovedNodes(parent, finalNodes);
+  const tCommit = commitBulkReplace(parent, finalNodes);
+  keyedElements.delete(parent);
+  const stats = {
+    n: newChildren.length,
+    reused,
+    created,
+    tBuild,
+    tCommit
+  };
+  recordBulkTextStats(stats);
+  return stats;
+}
+function processChildNode(vnode, existingNode, finalNodes) {
+  if (typeof vnode === "string" || typeof vnode === "number") {
+    return processTextVnode(String(vnode), existingNode, finalNodes);
+  }
+  if (typeof vnode === "object" && vnode !== null && "type" in vnode) {
+    return processElementVnode(vnode, existingNode, finalNodes);
+  }
+  return "skipped";
+}
+function processTextVnode(text, existingNode, finalNodes) {
+  if (existingNode && existingNode.nodeType === 3) {
+    existingNode.data = text;
+    finalNodes.push(existingNode);
+    return "reused";
+  }
+  finalNodes.push(document.createTextNode(text));
+  return "created";
+}
+function processElementVnode(vnode, existingNode, finalNodes) {
+  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);
+      return "reused";
     }
   }
-  const tBuild = (typeof performance !== "undefined" && performance.now ? performance.now() : Date.now()) - t0;
+  const dom = createDOMNode(vnode);
+  if (dom) {
+    finalNodes.push(dom);
+    return "created";
+  }
+  return "skipped";
+}
+function cleanupRemovedNodes(parent, keepNodes) {
   try {
     const toRemove = Array.from(parent.childNodes).filter(
-      (n) => !finalNodes.includes(n)
+      (n) => !keepNodes.includes(n)
     );
     for (const n of toRemove) {
       if (n instanceof Element) removeAllListeners(n);
       cleanupInstanceIfPresent(n);
     }
-  } catch (e) {
-    void e;
+  } catch {
   }
+}
+function commitBulkReplace(parent, nodes) {
   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;
+  for (let i = 0; i < nodes.length; i++) {
+    fragment.appendChild(nodes[i]);
   }
+  recordDOMReplace("bulk-text-replace");
   parent.replaceChildren(fragment);
-  const tCommit = Date.now() - fragStart;
-  keyedElements.delete(parent);
-  const stats = {
-    n: newChildren.length,
-    reused,
-    created,
-    tBuild,
-    tCommit
-  };
+  return Date.now() - fragStart;
+}
+function recordBulkTextStats(stats) {
   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;
+  } catch {
   }
-  return stats;
 }
 function isBulkTextFastPathEligible(parent, newChildren) {
   const threshold = Number(process.env.ASKR_BULK_TEXT_THRESHOLD) || 1024;
   const requiredFraction = 0.8;
   const total = Array.isArray(newChildren) ? newChildren.length : 0;
   if (total < threshold) {
-    if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
-      try {
-        __ASKR_set("__BULK_DIAG", {
-          phase: "bulk-unkeyed-eligible",
-          reason: "too-small",
-          total,
-          threshold
-        });
-      } catch (e) {
-        void e;
-      }
-    }
+    recordBulkDiag({
+      phase: "bulk-unkeyed-eligible",
+      reason: "too-small",
+      total,
+      threshold
+    });
+    return false;
+  }
+  const result = countSimpleChildren(newChildren);
+  if (result.componentFound !== void 0) {
+    recordBulkDiag({
+      phase: "bulk-unkeyed-eligible",
+      reason: "component-child",
+      index: result.componentFound
+    });
     return false;
   }
+  const fraction = result.simple / total;
+  const eligible = fraction >= requiredFraction && parent.childNodes.length >= total;
+  recordBulkDiag({
+    phase: "bulk-unkeyed-eligible",
+    total,
+    simple: result.simple,
+    fraction,
+    requiredFraction,
+    eligible
+  });
+  return eligible;
+}
+function countSimpleChildren(children) {
   let simple = 0;
-  for (let i = 0; i < newChildren.length; i++) {
-    const c = newChildren[i];
+  for (let i = 0; i < children.length; i++) {
+    const c = children[i];
     if (typeof c === "string" || typeof c === "number") {
       simple++;
       continue;
@@ -1406,71 +1546,34 @@ function isBulkTextFastPathEligible(parent, newChildren) {
     if (typeof c === "object" && c !== null && "type" in c) {
       const dv = c;
       if (typeof dv.type === "function") {
-        if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
-          try {
-            __ASKR_set("__BULK_DIAG", {
-              phase: "bulk-unkeyed-eligible",
-              reason: "component-child",
-              index: i
-            });
-          } catch (e) {
-            void e;
-          }
-        }
-        return false;
+        return { simple, componentFound: i };
       }
-      if (typeof dv.type === "string") {
-        const children = dv.children || dv.props?.children;
-        if (!children) {
-          simple++;
-          continue;
-        }
-        if (Array.isArray(children)) {
-          if (children.length === 1 && (typeof children[0] === "string" || typeof children[0] === "number")) {
-            simple++;
-            continue;
-          }
-        } else if (typeof children === "string" || typeof children === "number") {
-          simple++;
-          continue;
-        }
+      if (typeof dv.type === "string" && isSimpleElement(dv)) {
+        simple++;
       }
     }
   }
-  const fraction = simple / total;
-  const eligible = fraction >= requiredFraction && parent.childNodes.length >= total;
+  return { simple };
+}
+function isSimpleElement(dv) {
+  const children = dv.children || dv.props?.children;
+  if (!children) return true;
+  if (typeof children === "string" || typeof children === "number") {
+    return true;
+  }
+  if (Array.isArray(children) && children.length === 1 && (typeof children[0] === "string" || typeof children[0] === "number")) {
+    return true;
+  }
+  return false;
+}
+function recordBulkDiag(data) {
   if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
     try {
-      __ASKR_set("__BULK_DIAG", {
-        phase: "bulk-unkeyed-eligible",
-        total,
-        simple,
-        fraction,
-        requiredFraction,
-        eligible
-      });
-    } catch (e) {
-      void e;
+      __ASKR_set("__BULK_DIAG", data);
+    } catch {
     }
   }
-  return eligible;
 }
-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) {
@@ -1635,320 +1738,571 @@ function applyRendererFastPath(parent, keyedVnodes, oldKeyMap, unkeyedVnodes) {
     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();
+  logReconcileDebug(newChildren);
+  const { keyedVnodes, unkeyedVnodes } = partitionChildren(newChildren);
+  const fastPathResult = tryFastPaths(
+    parent,
+    newChildren,
+    keyedVnodes,
+    unkeyedVnodes,
+    oldKeyMap
+  );
+  if (fastPathResult) return fastPathResult;
+  return performFullReconciliation(parent, newChildren, keyedVnodes, oldKeyMap);
+}
+function logReconcileDebug(newChildren) {
+  if (process.env.NODE_ENV !== "production") {
+    try {
+      logger.warn(
+        "[Askr][RECONCILE] reconcileKeyedChildren newChildren sample",
+        {
+          sample: newChildren && newChildren.length && newChildren[0] || null,
+          len: newChildren.length
+        }
+      );
+    } catch {
+    }
+  }
+}
+function partitionChildren(newChildren) {
   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);
-      }
+    const key = extractKey(child);
+    if (key !== void 0) {
+      keyedVnodes.push({ key, vnode: child });
     } else {
       unkeyedVnodes.push(child);
     }
   }
+  return { keyedVnodes, unkeyedVnodes };
+}
+function tryFastPaths(parent, newChildren, keyedVnodes, unkeyedVnodes, oldKeyMap) {
   try {
-    const decision = isKeyedReorderFastPathEligible(
+    const rendererResult = tryRendererFastPath(
       parent,
       newChildren,
+      keyedVnodes,
+      unkeyedVnodes,
       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;
+    if (rendererResult) return rendererResult;
+    const positionalResult = tryPositionalBulkUpdate(parent, keyedVnodes);
+    if (positionalResult) return positionalResult;
+  } catch {
+  }
+  return null;
+}
+function tryRendererFastPath(parent, newChildren, keyedVnodes, unkeyedVnodes, oldKeyMap) {
+  const decision = isKeyedReorderFastPathEligible(
+    parent,
+    newChildren,
+    oldKeyMap
+  );
+  if (decision.useFastPath && keyedVnodes.length >= 128 || isBulkCommitActive2()) {
+    try {
+      const map = applyRendererFastPath(
+        parent,
+        keyedVnodes,
+        oldKeyMap,
+        unkeyedVnodes
+      );
+      if (map) {
+        keyedElements.set(parent, map);
+        return map;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function tryPositionalBulkUpdate(parent, keyedVnodes) {
+  const total = keyedVnodes.length;
+  if (total < 10) return null;
+  const matchCount = countPositionalMatches(parent, keyedVnodes);
+  logPositionalCheck(total, matchCount, parent.children.length);
+  if (matchCount / total < 0.9) return null;
+  if (hasPositionalPropChanges(parent, keyedVnodes)) return null;
+  try {
+    const stats = performBulkPositionalKeyedTextUpdate(parent, keyedVnodes);
+    recordFastPathStats(stats, "bulkKeyedPositionalHits");
+    rebuildKeyedMap(parent);
+    return keyedElements.get(parent);
+  } catch {
+    return null;
+  }
+}
+function countPositionalMatches(parent, keyedVnodes) {
+  let matchCount = 0;
+  try {
+    for (let i = 0; i < keyedVnodes.length; 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 {
+  }
+  return matchCount;
+}
+function logPositionalCheck(total, matchCount, parentChildren) {
+  if (process.env.NODE_ENV !== "production") {
     try {
-      const total = keyedVnodes.length;
-      if (total >= 10) {
-        let matchCount = 0;
-        try {
-          for (let i = 0; i < total; i++) {
-            const vnode = keyedVnodes[i].vnode;
-            if (!vnode || typeof vnode !== "object" || typeof vnode.type !== "string")
-              continue;
-            const el = parent.children[i];
-            if (!el) continue;
-            if (el.tagName.toLowerCase() === String(vnode.type).toLowerCase())
-              matchCount++;
-          }
-        } catch (e) {
-          void e;
-        }
-        if (matchCount / total >= 0.9) {
-          let hasPropChanges = false;
-          try {
-            for (let i = 0; i < total; i++) {
-              const vnode = keyedVnodes[i].vnode;
-              const el = parent.children[i];
-              if (!el || !vnode || typeof vnode !== "object") continue;
-              const props = vnode.props || {};
-              for (const k of Object.keys(props)) {
-                if (k === "children" || k === "key") continue;
-                if (k.startsWith("on") && k.length > 2) continue;
-                if (k.startsWith("data-")) continue;
-                const v = props[k];
-                try {
-                  if (k === "class" || k === "className") {
-                    if (el.className !== String(v)) {
-                      hasPropChanges = true;
-                      break;
-                    }
-                  } else if (k === "value" || k === "checked") {
-                    if (el[k] !== v) {
-                      hasPropChanges = true;
-                      break;
-                    }
-                  } else {
-                    const attr = el.getAttribute(k);
-                    if (v === void 0 || v === null || v === false) {
-                      if (attr !== null) {
-                        hasPropChanges = true;
-                        break;
-                      }
-                    } else if (String(v) !== attr) {
-                      hasPropChanges = true;
-                      break;
-                    }
-                  }
-                } catch (e) {
-                  hasPropChanges = true;
-                  void e;
-                  break;
-                }
-              }
-              if (hasPropChanges) break;
-            }
-          } catch (e) {
-            void e;
-          }
-          if (hasPropChanges) {
-          } else {
-            try {
-              const stats = performBulkPositionalKeyedTextUpdate(
-                parent,
-                keyedVnodes
-              );
-              if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
-                try {
-                  __ASKR_set("__LAST_FASTPATH_STATS", stats);
-                  __ASKR_set("__LAST_FASTPATH_COMMIT_COUNT", 1);
-                  __ASKR_incCounter("bulkKeyedPositionalHits");
-                } catch (e) {
-                  void e;
-                }
-              }
-              try {
-                const map = /* @__PURE__ */ new Map();
-                const children = Array.from(parent.children);
-                for (let i = 0; i < children.length; i++) {
-                  const el = children[i];
-                  const k = el.getAttribute("data-key");
-                  if (k !== null) {
-                    map.set(k, el);
-                    const n = Number(k);
-                    if (!Number.isNaN(n)) map.set(n, el);
-                  }
-                }
-                keyedElements.set(parent, map);
-              } catch (e) {
-                void e;
-              }
-              return keyedElements.get(parent);
-            } catch (e) {
-              void e;
-            }
-          }
-        }
+      logger.warn("[Askr][FASTPATH] positional check", {
+        total,
+        matchCount,
+        parentChildren
+      });
+    } catch {
+    }
+  }
+}
+function hasPositionalPropChanges(parent, keyedVnodes) {
+  try {
+    for (let i = 0; i < keyedVnodes.length; i++) {
+      const vnode = keyedVnodes[i].vnode;
+      const el = parent.children[i];
+      if (!el || !vnode || typeof vnode !== "object") continue;
+      if (checkPropChanges(el, vnode.props || {})) {
+        return true;
       }
-    } catch (e) {
-      void e;
     }
-  } catch (e) {
-    void e;
+  } catch {
+    return true;
+  }
+  return false;
+}
+function rebuildKeyedMap(parent) {
+  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 {
+  }
+}
+function performFullReconciliation(parent, newChildren, keyedVnodes, oldKeyMap) {
+  const newKeyMap = /* @__PURE__ */ new Map();
+  const finalNodes = [];
+  const usedOldEls = /* @__PURE__ */ new WeakSet();
+  const resolveOldElOnce = createOldElResolver(parent, oldKeyMap, usedOldEls);
+  for (let i = 0; i < newChildren.length; i++) {
+    const child = newChildren[i];
+    const node = reconcileSingleChild(
+      child,
+      i,
+      parent,
+      resolveOldElOnce,
+      usedOldEls,
+      newKeyMap
+    );
+    if (node) finalNodes.push(node);
+  }
+  if (typeof document === "undefined") return newKeyMap;
+  commitReconciliation(parent, finalNodes);
+  keyedElements.delete(parent);
+  return newKeyMap;
+}
+function createOldElResolver(parent, oldKeyMap, usedOldEls) {
+  return (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(s);
+    if (!Number.isNaN(n)) {
+      const byNum = oldKeyMap.get(n);
+      if (byNum && !usedOldEls.has(byNum)) {
+        usedOldEls.add(byNum);
+        return byNum;
+      }
+    }
+    return scanForElementByKey(parent, k, s, usedOldEls);
+  };
+}
+function scanForElementByKey(parent, k, keyStr, usedOldEls) {
+  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 === keyStr) {
+        usedOldEls.add(ch);
+        return ch;
+      }
+      const numAttr = Number(attr);
+      if (!Number.isNaN(numAttr) && numAttr === k) {
+        usedOldEls.add(ch);
+        return ch;
+      }
+    }
+  } catch {
+  }
+  return void 0;
+}
+function reconcileSingleChild(child, index, parent, resolveOldElOnce, usedOldEls, newKeyMap) {
+  const key = extractKey(child);
+  if (key !== void 0) {
+    return reconcileKeyedChild(child, key, parent, resolveOldElOnce, newKeyMap);
+  }
+  return reconcileUnkeyedChild(child, index, parent, usedOldEls);
+}
+function reconcileKeyedChild(child, key, parent, resolveOldElOnce, newKeyMap) {
+  const el = resolveOldElOnce(key);
+  if (el && el.parentElement === parent) {
+    updateElementFromVnode(el, child);
+    newKeyMap.set(key, el);
+    return el;
+  }
+  const dom = createDOMNode(child);
+  if (dom) {
+    if (dom instanceof Element) newKeyMap.set(key, dom);
+    return dom;
+  }
+  return null;
+}
+function reconcileUnkeyedChild(child, index, parent, usedOldEls) {
+  try {
+    const existing = parent.children[index];
+    if (existing && (typeof child === "string" || typeof child === "number") && existing.nodeType === 1) {
+      existing.textContent = String(child);
+      usedOldEls.add(existing);
+      return existing;
+    }
+    if (canReuseElement(existing, child)) {
+      updateElementFromVnode(existing, child);
+      usedOldEls.add(existing);
+      return existing;
+    }
+    const avail = findAvailableUnkeyedElement(parent, usedOldEls);
+    if (avail) {
+      const reuseResult = tryReuseElement(avail, child, usedOldEls);
+      if (reuseResult) return reuseResult;
+    }
+  } catch {
+  }
+  const dom = createDOMNode(child);
+  return dom;
+}
+function canReuseElement(existing, child) {
+  if (!existing) return false;
+  if (typeof child !== "object" || child === null || !("type" in child))
+    return false;
+  const childObj = child;
+  const hasNoKey = existing.getAttribute("data-key") === null || existing.getAttribute("data-key") === void 0;
+  return hasNoKey && typeof childObj.type === "string" && existing.tagName.toLowerCase() === String(childObj.type).toLowerCase();
+}
+function findAvailableUnkeyedElement(parent, usedOldEls) {
+  return Array.from(parent.children).find(
+    (ch) => !usedOldEls.has(ch) && ch.getAttribute("data-key") === null
+  );
+}
+function tryReuseElement(avail, child, usedOldEls) {
+  if (typeof child === "string" || typeof child === "number") {
+    avail.textContent = String(child);
+    usedOldEls.add(avail);
+    return avail;
+  }
+  if (typeof child === "object" && child !== null && "type" in child) {
+    const childObj = child;
+    if (typeof childObj.type === "string" && avail.tagName.toLowerCase() === String(childObj.type).toLowerCase()) {
+      updateElementFromVnode(avail, child);
+      usedOldEls.add(avail);
+      return avail;
+    }
+  }
+  return null;
+}
+function commitReconciliation(parent, finalNodes) {
+  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 {
+  }
+  recordDOMReplace("reconcile");
+  parent.replaceChildren(fragment);
+}
+
+// src/renderer/evaluate.ts
+var domRanges = /* @__PURE__ */ new WeakMap();
+function checkSimpleText(vnodeChildren) {
+  if (!Array.isArray(vnodeChildren)) {
+    if (typeof vnodeChildren === "string" || typeof vnodeChildren === "number") {
+      return { isSimple: true, text: String(vnodeChildren) };
+    }
+  } else if (vnodeChildren.length === 1) {
+    const child = vnodeChildren[0];
+    if (typeof child === "string" || typeof child === "number") {
+      return { isSimple: true, text: String(child) };
+    }
+  }
+  return { isSimple: false };
+}
+function tryUpdateTextInPlace(element, text) {
+  if (element.childNodes.length === 1 && element.firstChild?.nodeType === 3) {
+    element.firstChild.data = text;
+    return true;
+  }
+  return false;
+}
+function buildKeyMapFromDOM(parent) {
+  const keyMap = /* @__PURE__ */ new Map();
+  const children = Array.from(parent.children);
+  for (const child of children) {
+    const k = child.getAttribute("data-key");
+    if (k !== null) {
+      keyMap.set(k, child);
+      const n = Number(k);
+      if (!Number.isNaN(n)) keyMap.set(n, child);
+    }
+  }
+  return keyMap;
+}
+function getOrBuildKeyMap(parent) {
+  let keyMap = keyedElements.get(parent);
+  if (!keyMap) {
+    keyMap = buildKeyMapFromDOM(parent);
+    if (keyMap.size > 0) {
+      keyedElements.set(parent, keyMap);
+    }
+  }
+  return keyMap.size > 0 ? keyMap : void 0;
+}
+function hasKeyedChildren(children) {
+  return children.some(
+    (child) => typeof child === "object" && child !== null && "key" in child
+  );
+}
+function trackBulkTextStats(stats) {
+  if (process.env.NODE_ENV !== "production") {
+    try {
+      __ASKR_set("__LAST_BULK_TEXT_FASTPATH_STATS", stats);
+      __ASKR_incCounter("bulkTextHits");
+    } catch {
+    }
+  }
+}
+function trackBulkTextMiss() {
+  if (process.env.NODE_ENV !== "production") {
+    try {
+      __ASKR_incCounter("bulkTextMisses");
+    } catch {
+    }
   }
-  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;
+}
+function reconcileKeyed(parent, children, oldKeyMap) {
+  if (process.env.ASKR_FORCE_BULK_POSREUSE === "1") {
+    const result = tryForcedBulkKeyedPath(parent, children);
+    if (result) return;
+  }
+  const newKeyMap = reconcileKeyedChildren(parent, children, oldKeyMap);
+  keyedElements.set(parent, newKeyMap);
+}
+function tryForcedBulkKeyedPath(parent, children) {
+  try {
+    const keyedVnodes = [];
+    for (const child of children) {
+      if (_isDOMElement(child) && child.key !== void 0) {
+        keyedVnodes.push({
+          key: child.key,
+          vnode: child
+        });
+      }
     }
-    const s = String(k);
-    const byString = oldKeyMap.get(s);
-    if (byString && !usedOldEls.has(byString)) {
-      usedOldEls.add(byString);
-      return byString;
+    if (keyedVnodes.length === 0 || keyedVnodes.length !== children.length) {
+      return false;
     }
-    const n = Number(String(k));
-    if (!Number.isNaN(n)) {
-      const byNum = oldKeyMap.get(n);
-      if (byNum && !usedOldEls.has(byNum)) {
-        usedOldEls.add(byNum);
-        return byNum;
+    if (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(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("bulkKeyedPositionalForced");
+      } catch {
       }
     }
+    const newMap = buildKeyMapFromDOM(parent);
+    keyedElements.set(parent, newMap);
+    return true;
+  } catch (err) {
+    if (process.env.ASKR_FASTPATH_DEBUG === "1" || process.env.ASKR_FASTPATH_DEBUG === "true") {
+      logger.warn(
+        "[Askr][FASTPATH] forced bulk path failed, falling back",
+        err
+      );
+    }
+    return false;
+  }
+}
+function reconcileUnkeyed(parent, children) {
+  if (isBulkTextFastPathEligible(parent, children)) {
+    const stats = performBulkTextReplace(parent, children);
+    trackBulkTextStats(stats);
+  } else {
+    trackBulkTextMiss();
+    updateUnkeyedChildren(parent, children);
+  }
+  keyedElements.delete(parent);
+}
+function updateElementChildren2(element, vnodeChildren) {
+  if (!vnodeChildren) {
+    element.textContent = "";
+    keyedElements.delete(element);
+    return;
+  }
+  if (!Array.isArray(vnodeChildren)) {
+    element.textContent = "";
+    const dom = createDOMNode(vnodeChildren);
+    if (dom) element.appendChild(dom);
+    keyedElements.delete(element);
+    return;
+  }
+  if (hasKeyedChildren(vnodeChildren)) {
+    const oldKeyMap = getOrBuildKeyMap(element);
     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;
+      reconcileKeyed(element, vnodeChildren, oldKeyMap);
+    } catch {
+      const newKeyMap = reconcileKeyedChildren(
+        element,
+        vnodeChildren,
+        oldKeyMap
+      );
+      keyedElements.set(element, newKeyMap);
     }
-    return void 0;
-  };
-  for (let i = 0; i < newChildren.length; i++) {
-    const child = newChildren[i];
-    if (typeof child === "object" && child !== null && "type" in child) {
-      const childObj = child;
-      const rawKey = childObj.key ?? childObj.props?.key;
-      if (rawKey !== void 0) {
-        const key = typeof rawKey === "symbol" ? String(rawKey) : rawKey;
-        const el = resolveOldElOnce(key);
-        if (el && el.parentElement === parent) {
-          updateElementFromVnode(el, child);
-          finalNodes.push(el);
-          newKeyMap.set(key, el);
-          continue;
-        }
-        const dom2 = createDOMNode(child);
-        if (dom2) {
-          finalNodes.push(dom2);
-          if (dom2 instanceof Element) newKeyMap.set(key, dom2);
-        }
-        continue;
+  } else {
+    reconcileUnkeyed(element, vnodeChildren);
+  }
+}
+function smartUpdateElement(element, vnode) {
+  const vnodeChildren = vnode.children || vnode.props?.children;
+  const textCheck = checkSimpleText(vnodeChildren);
+  if (textCheck.isSimple && tryUpdateTextInPlace(element, textCheck.text)) {
+  } else {
+    updateElementChildren2(element, vnodeChildren);
+  }
+  updateElementFromVnode(element, vnode, false);
+}
+function processFragmentChildren(target, childArray) {
+  const existingChildren = Array.from(target.children);
+  for (let i = 0; i < childArray.length; i++) {
+    const childVnode = childArray[i];
+    const existingNode = existingChildren[i];
+    if (existingNode && _isDOMElement(childVnode) && typeof childVnode.type === "string" && existingNode.tagName.toLowerCase() === childVnode.type.toLowerCase()) {
+      smartUpdateElement(existingNode, childVnode);
+      continue;
+    }
+    const newDom = createDOMNode(childVnode);
+    if (newDom) {
+      if (existingNode) {
+        target.replaceChild(newDom, existingNode);
+      } else {
+        target.appendChild(newDom);
       }
     }
+  }
+  while (target.children.length > childArray.length) {
+    target.removeChild(target.lastChild);
+  }
+}
+function createWrappedEventHandler(handler) {
+  return (event) => {
+    globalScheduler.setInHandler(true);
     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;
+      handler(event);
+    } catch (error) {
+      logger.error("[Askr] Event handler error:", error);
+    } finally {
+      globalScheduler.setInHandler(false);
+    }
+  };
+}
+function applyPropsToElement2(el, 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 = createWrappedEventHandler(value);
+      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);
       }
-      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;
+      if (!elementListeners.has(el)) {
+        elementListeners.set(el, /* @__PURE__ */ new Map());
       }
-    } catch (e) {
-      void e;
+      elementListeners.get(el).set(eventName, {
+        handler: wrappedHandler,
+        original: value,
+        options
+      });
+      continue;
     }
-    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);
+    if (key === "class" || key === "className") {
+      el.className = String(value);
+    } else if (key === "value" || key === "checked") {
+      el[key] = value;
+    } else {
+      el.setAttribute(key, String(value));
     }
-  } catch (e) {
-    void e;
-  }
-  try {
-    __ASKR_incCounter("__DOM_REPLACE_COUNT");
-    __ASKR_set("__LAST_DOM_REPLACE_STACK_RECONCILE", new Error().stack);
-  } catch (e) {
-    void e;
   }
-  parent.replaceChildren(fragment);
-  keyedElements.delete(parent);
-  return newKeyMap;
 }
-var init_reconcile = __esm({
-  "src/renderer/reconcile.ts"() {
-    "use strict";
-    init_dom();
-    init_keyed();
-    init_cleanup();
-    init_fastlane_shared();
-    init_diag();
-    init_fastpath();
+function tryFirstRenderKeyedChildren(target, vnode) {
+  const children = vnode.children;
+  if (!Array.isArray(children) || !hasKeyedChildren(children)) {
+    return false;
   }
-});
-
-// src/renderer/evaluate.ts
+  const el = document.createElement(vnode.type);
+  target.appendChild(el);
+  applyPropsToElement2(el, vnode.props || {});
+  const newKeyMap = reconcileKeyedChildren(el, children, void 0);
+  keyedElements.set(el, newKeyMap);
+  return true;
+}
+function isFragment(vnode) {
+  return _isDOMElement(vnode) && typeof vnode.type === "symbol" && (vnode.type === Fragment || String(vnode.type) === "Symbol(askr.fragment)");
+}
+function getFragmentChildren(vnode) {
+  const fragmentChildren = vnode.props?.children || vnode.children || [];
+  return Array.isArray(fragmentChildren) ? fragmentChildren : [fragmentChildren];
+}
 function evaluate(node, target, context) {
   if (!target) return;
   if (typeof document === "undefined") {
@@ -1984,228 +2338,23 @@ function evaluate(node, target, context) {
       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;
+    let vnode = node;
+    if (isFragment(vnode)) {
+      const childArray = getFragmentChildren(vnode);
+      if (childArray.length === 1 && _isDOMElement(childArray[0]) && typeof childArray[0].type === "string") {
+        vnode = childArray[0];
       } else {
-        if (vnodeChildren) {
-          if (Array.isArray(vnodeChildren)) {
-            const hasKeys = vnodeChildren.some(
-              (child) => typeof child === "object" && child !== null && "key" in child
-            );
-            if (hasKeys) {
-              let oldKeyMap = keyedElements.get(firstChild);
-              if (!oldKeyMap) {
-                oldKeyMap = /* @__PURE__ */ new Map();
-                try {
-                  const children = Array.from(firstChild.children);
-                  for (let i = 0; i < children.length; i++) {
-                    const ch = children[i];
-                    const k = ch.getAttribute("data-key");
-                    if (k !== null) {
-                      oldKeyMap.set(k, ch);
-                      const n = Number(k);
-                      if (!Number.isNaN(n)) oldKeyMap.set(n, ch);
-                    }
-                  }
-                  if (oldKeyMap.size > 0)
-                    keyedElements.set(firstChild, oldKeyMap);
-                } catch (e) {
-                  void e;
-                }
-              }
-              try {
-                if (process.env.ASKR_FORCE_BULK_POSREUSE === "1") {
-                  try {
-                    const keyedVnodes = [];
-                    for (let i = 0; i < vnodeChildren.length; i++) {
-                      const c = vnodeChildren[i];
-                      if (_isDOMElement(c) && c.key !== void 0) {
-                        keyedVnodes.push({
-                          key: c.key,
-                          vnode: c
-                        });
-                      }
-                    }
-                    if (keyedVnodes.length > 0 && keyedVnodes.length === vnodeChildren.length) {
-                      if (process.env.ASKR_FASTPATH_DEBUG === "1" || process.env.ASKR_FASTPATH_DEBUG === "true") {
-                        logger.warn(
-                          "[Askr][FASTPATH] forced positional bulk keyed reuse (evaluate-level)"
-                        );
-                      }
-                      const stats = performBulkPositionalKeyedTextUpdate(
-                        firstChild,
-                        keyedVnodes
-                      );
-                      if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
-                        try {
-                          __ASKR_set("__LAST_FASTPATH_STATS", stats);
-                          __ASKR_set("__LAST_FASTPATH_COMMIT_COUNT", 1);
-                          __ASKR_incCounter("bulkKeyedPositionalForced");
-                        } catch (e) {
-                          void e;
-                        }
-                      }
-                      try {
-                        const map = /* @__PURE__ */ new Map();
-                        const children = Array.from(firstChild.children);
-                        for (let i = 0; i < children.length; i++) {
-                          const el = children[i];
-                          const k = el.getAttribute("data-key");
-                          if (k !== null) {
-                            map.set(k, el);
-                            const n = Number(k);
-                            if (!Number.isNaN(n)) map.set(n, el);
-                          }
-                        }
-                        keyedElements.set(firstChild, map);
-                      } catch (e) {
-                        void e;
-                      }
-                    } else {
-                      const newKeyMap = reconcileKeyedChildren(
-                        firstChild,
-                        vnodeChildren,
-                        oldKeyMap
-                      );
-                      keyedElements.set(firstChild, newKeyMap);
-                    }
-                  } catch (err) {
-                    if (process.env.ASKR_FASTPATH_DEBUG === "1" || process.env.ASKR_FASTPATH_DEBUG === "true") {
-                      logger.warn(
-                        "[Askr][FASTPATH] forced bulk path failed, falling back",
-                        err
-                      );
-                    }
-                    const newKeyMap = reconcileKeyedChildren(
-                      firstChild,
-                      vnodeChildren,
-                      oldKeyMap
-                    );
-                    keyedElements.set(firstChild, newKeyMap);
-                  }
-                } else {
-                  const newKeyMap = reconcileKeyedChildren(
-                    firstChild,
-                    vnodeChildren,
-                    oldKeyMap
-                  );
-                  keyedElements.set(firstChild, newKeyMap);
-                }
-              } catch (e) {
-                void e;
-                const newKeyMap = reconcileKeyedChildren(
-                  firstChild,
-                  vnodeChildren,
-                  oldKeyMap
-                );
-                keyedElements.set(firstChild, newKeyMap);
-              }
-            } else {
-              if (isBulkTextFastPathEligible(firstChild, vnodeChildren)) {
-                const stats = performBulkTextReplace(firstChild, vnodeChildren);
-                if (process.env.NODE_ENV !== "production") {
-                  try {
-                    __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);
-              }
-            }
-          } else {
-            firstChild.textContent = "";
-            const dom = createDOMNode(vnodeChildren);
-            if (dom) firstChild.appendChild(dom);
-            keyedElements.delete(firstChild);
-          }
-        } else {
-          firstChild.textContent = "";
-          keyedElements.delete(firstChild);
-        }
+        processFragmentChildren(target, childArray);
+        return;
       }
-      updateElementFromVnode(firstChild, vnode, false);
+    }
+    const firstChild = target.children[0];
+    if (firstChild && _isDOMElement(vnode) && typeof vnode.type === "string" && firstChild.tagName.toLowerCase() === vnode.type.toLowerCase()) {
+      smartUpdateElement(firstChild, vnode);
     } 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 (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;
-        }
+      if (_isDOMElement(vnode) && typeof vnode.type === "string" && tryFirstRenderKeyedChildren(target, vnode)) {
+        return;
       }
       const dom = createDOMNode(vnode);
       if (dom) {
@@ -2214,43 +2363,16 @@ function evaluate(node, target, context) {
     }
   }
 }
-var domRanges;
-var init_evaluate = __esm({
-  "src/renderer/evaluate.ts"() {
-    "use strict";
-    init_scheduler();
-    init_logger();
-    init_cleanup();
-    init_keyed();
-    init_reconcile();
-    init_types();
-    init_dom();
-    init_diag();
-    domRanges = /* @__PURE__ */ new WeakMap();
-  }
-});
 
 // 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 = {
-        evaluate,
-        isKeyedReorderFastPathEligible,
-        getKeyMapForElement
-      };
-    }
-  }
-});
+if (typeof globalThis !== "undefined") {
+  const _g = globalThis;
+  _g.__ASKR_RENDERER = {
+    evaluate,
+    isKeyedReorderFastPathEligible,
+    getKeyMapForElement
+  };
+}
 
 // src/runtime/component.ts
 function createComponentInstance(id, fn, props, target) {
@@ -2302,6 +2424,8 @@ function createComponentInstance(id, fn, props, target) {
   };
   return instance;
 }
+var currentInstance = null;
+var stateIndex = 0;
 function getCurrentComponentInstance() {
   return currentInstance;
 }
@@ -2353,6 +2477,7 @@ function mountInstanceInline(instance, target) {
     executeMountOperations(instance);
   }
 }
+var _globalRenderCounter = 0;
 function runComponent(instance) {
   instance.notifyUpdate = instance._enqueueRun;
   instance._currentRenderToken = ++_globalRenderCounter;
@@ -2372,6 +2497,34 @@ function runComponent(instance) {
       if (process.env.NODE_ENV !== "production") throw err;
     }
     globalScheduler.enqueue(() => {
+      if (!instance.target && instance._placeholder) {
+        if (result === null || result === void 0) {
+          finalizeReadSubscriptions(instance);
+          return;
+        }
+        const placeholder = instance._placeholder;
+        const parent = placeholder.parentNode;
+        if (!parent) {
+          logger.warn(
+            "[Askr] placeholder no longer in DOM, cannot render component"
+          );
+          return;
+        }
+        const host = document.createElement("div");
+        const oldInstance = currentInstance;
+        currentInstance = instance;
+        try {
+          evaluate(result, host);
+          parent.replaceChild(host, placeholder);
+          instance.target = host;
+          instance._placeholder = void 0;
+          host.__ASKR_INSTANCE = instance;
+          finalizeReadSubscriptions(instance);
+        } finally {
+          currentInstance = oldInstance;
+        }
+        return;
+      }
       if (instance.target) {
         let oldChildren = [];
         try {
@@ -2454,6 +2607,8 @@ function runComponent(instance) {
 }
 function renderComponentInline(instance) {
   const hadToken = instance._currentRenderToken !== void 0;
+  const prevToken = instance._currentRenderToken;
+  const prevPendingReads = instance._pendingReadStates;
   if (!hadToken) {
     instance._currentRenderToken = ++_globalRenderCounter;
     instance._pendingReadStates = /* @__PURE__ */ new Set();
@@ -2465,10 +2620,8 @@ function renderComponentInline(instance) {
     }
     return result;
   } finally {
-    if (!hadToken) {
-      instance._pendingReadStates = /* @__PURE__ */ new Set();
-      instance._currentRenderToken = void 0;
-    }
+    instance._currentRenderToken = prevToken;
+    instance._pendingReadStates = prevPendingReads ?? /* @__PURE__ */ new Set();
   }
 }
 function executeComponentSync(instance) {
@@ -2599,75 +2752,11 @@ function cleanupComponent(instance) {
     instance._lastReadStates = /* @__PURE__ */ new Set();
   }
   instance.abortController.abort();
-}
-var currentInstance, stateIndex, _globalRenderCounter;
-var init_component = __esm({
-  "src/runtime/component.ts"() {
-    "use strict";
-    init_scheduler();
-    init_context();
-    init_logger();
-    init_diag();
-    init_fastlane_shared();
-    init_renderer();
-    currentInstance = null;
-    stateIndex = 0;
-    _globalRenderCounter = 0;
-  }
-});
-
-// src/router/route.ts
-var route_exports = {};
-__export(route_exports, {
-  _lockRouteRegistrationForTests: () => _lockRouteRegistrationForTests,
-  _unlockRouteRegistrationForTests: () => _unlockRouteRegistrationForTests,
-  clearRoutes: () => clearRoutes,
-  getLoadedNamespaces: () => getLoadedNamespaces,
-  getNamespaceRoutes: () => getNamespaceRoutes,
-  getRoutes: () => getRoutes,
-  lockRouteRegistration: () => lockRouteRegistration,
-  registerRoute: () => registerRoute,
-  resolveRoute: () => resolveRoute,
-  route: () => route,
-  setServerLocation: () => setServerLocation,
-  unloadNamespace: () => unloadNamespace
-});
-
-// src/router/match.ts
-function match(path, pattern) {
-  const normalizedPath = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
-  const normalizedPattern = pattern.endsWith("/") && pattern !== "/" ? pattern.slice(0, -1) : pattern;
-  const pathSegments = normalizedPath.split("/").filter(Boolean);
-  const patternSegments = normalizedPattern.split("/").filter(Boolean);
-  if (patternSegments.length === 1 && patternSegments[0] === "*") {
-    return {
-      matched: true,
-      params: {
-        "*": pathSegments.length > 1 ? normalizedPath : pathSegments[0]
-      }
-    };
-  }
-  if (pathSegments.length !== patternSegments.length) {
-    return { matched: false, params: {} };
-  }
-  const params = {};
-  for (let i = 0; i < patternSegments.length; i++) {
-    const patternSegment = patternSegments[i];
-    const pathSegment = pathSegments[i];
-    if (patternSegment.startsWith("{") && patternSegment.endsWith("}")) {
-      const paramName = patternSegment.slice(1, -1);
-      params[paramName] = decodeURIComponent(pathSegment);
-    } else if (patternSegment === "*") {
-      params["*"] = pathSegment;
-    } else if (patternSegment !== pathSegment) {
-      return { matched: false, params: {} };
-    }
-  }
-  return { matched: true, params };
+  instance.notifyUpdate = null;
+  instance.mounted = false;
 }
 
 // src/router/route.ts
-init_component();
 var routes = [];
 var namespaces = /* @__PURE__ */ new Set();
 var routesByDepth = /* @__PURE__ */ new Map();
@@ -2981,31 +3070,34 @@ function resolveRoute(pathname) {
 
 export {
   invariant,
-  init_invariant,
   logger,
-  init_logger,
   globalScheduler,
   scheduleEventHandler,
-  init_scheduler,
   withAsyncResourceContext,
   defineContext,
   readContext,
   getCurrentContextFrame,
-  init_context,
+  setDevValue,
+  getDevValue,
+  enterBulkCommit,
+  exitBulkCommit,
   isBulkCommitActive2 as isBulkCommitActive,
-  init_fastlane_shared,
+  markFastPathApplied,
+  isFastPathApplied,
   removeAllListeners,
-  init_renderer,
+  getKeyMapForElement,
+  populateKeyMapForElement,
+  isKeyedReorderFastPathEligible,
   createComponentInstance,
   getCurrentComponentInstance,
   setCurrentComponentInstance,
   registerMountOperation,
   getCurrentInstance,
   getSignal,
+  finalizeReadSubscriptions,
   getNextStateIndex,
   mountComponent,
   cleanupComponent,
-  init_component,
   setServerLocation,
   lockRouteRegistration,
   _lockRouteRegistrationForTests,
@@ -3020,4 +3112,4 @@ export {
   resolveRoute,
   route_exports
 };
-//# sourceMappingURL=chunk-MIPES65F.js.map
+//# sourceMappingURL=chunk-2ONGHQ7Z.js.map