@askrjs/askr 0.0.4 → 0.0.5

package/dist/index.js

@@ -1,33 +1,3586 @@
-import {
-  state
-} from "./chunk-6FLMH4EL.js";
-import {
-  initializeNavigation,
-  registerAppInstance
-} from "./chunk-VRAEBIJ3.js";
-import {
-  DefaultPortal
-} from "./chunk-WTFWRSHB.js";
-import {
-  assertExecutionModel
-} from "./chunk-Z5ZSTLYF.js";
-import {
-  cleanupComponent,
-  createComponentInstance,
-  getCurrentComponentInstance,
-  globalScheduler,
-  logger,
-  mountComponent,
-  removeAllListeners
-} from "./chunk-XHKZGJE3.js";
-import "./chunk-SALJX5PZ.js";
-import {
-  ELEMENT_TYPE,
-  Fragment
-} from "./chunk-FJUXFA72.js";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/dev/invariant.ts
+function invariant(condition, message, context) {
+  if (!condition) {
+    const contextStr = "";
+    throw new Error(`[Askr Invariant] ${message}${contextStr}`);
+  }
+}
+function assertSchedulingPrecondition(condition, violationMessage) {
+  invariant(condition, `[Scheduler Precondition] ${violationMessage}`);
+}
+var init_invariant = __esm({
+  "src/dev/invariant.ts"() {
+  }
+});
+
+// src/dev/logger.ts
+function callConsole(method, args) {
+  const c = typeof console !== "undefined" ? console : void 0;
+  if (!c) return;
+  const fn = c[method];
+  if (typeof fn === "function") {
+    try {
+      fn.apply(console, args);
+    } catch {
+    }
+  }
+}
+var logger;
+var init_logger = __esm({
+  "src/dev/logger.ts"() {
+    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
+function isBulkCommitActive() {
+  try {
+    const fb = globalThis.__ASKR_FASTLANE;
+    return typeof fb?.isBulkCommitActive === "function" ? !!fb.isBulkCommitActive() : false;
+  } catch (e) {
+    return false;
+  }
+}
+function isSchedulerExecuting() {
+  return globalScheduler.isExecuting();
+}
+var MAX_FLUSH_DEPTH, Scheduler, globalScheduler;
+var init_scheduler = __esm({
+  "src/runtime/scheduler.ts"() {
+    init_invariant();
+    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;
+            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) {
+          }
+          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) {
+            }
+          });
+          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
+function withContext(frame, fn) {
+  const oldFrame = currentContextFrame;
+  currentContextFrame = frame;
+  try {
+    return fn();
+  } finally {
+    currentContextFrame = oldFrame;
+  }
+}
+function getCurrentContextFrame() {
+  return currentContextFrame;
+}
+var CONTEXT_FRAME_SYMBOL, currentContextFrame;
+var init_context = __esm({
+  "src/runtime/context.ts"() {
+    CONTEXT_FRAME_SYMBOL = /* @__PURE__ */ Symbol("__tempoContextFrame__");
+    currentContextFrame = null;
+  }
+});
+
+// src/renderer/diag/index.ts
+function getDiagMap() {
+  try {
+    const root = globalThis;
+    if (!root.__ASKR_DIAG) root.__ASKR_DIAG = {};
+    return root.__ASKR_DIAG;
+  } catch (e) {
+    return {};
+  }
+}
+function __ASKR_set(key, value) {
+  try {
+    const g = getDiagMap();
+    g[key] = value;
+    try {
+      const root = globalThis;
+      try {
+        const ns = root.__ASKR__ || (root.__ASKR__ = {});
+        try {
+          ns[key] = value;
+        } catch (e) {
+          void e;
+        }
+      } catch (e) {
+        void e;
+      }
+    } catch (e) {
+      void e;
+    }
+  } catch (e) {
+  }
+}
+function __ASKR_incCounter(key) {
+  try {
+    const g = getDiagMap();
+    const prev = typeof g[key] === "number" ? g[key] : 0;
+    const next = prev + 1;
+    g[key] = next;
+    try {
+      const root = globalThis;
+      const ns = root.__ASKR__ || (root.__ASKR__ = {});
+      try {
+        const nsPrev = typeof ns[key] === "number" ? ns[key] : 0;
+        ns[key] = nsPrev + 1;
+      } catch (e) {
+        void e;
+      }
+    } catch (e) {
+      void e;
+    }
+  } catch (e) {
+  }
+}
+var init_diag = __esm({
+  "src/renderer/diag/index.ts"() {
+  }
+});
+
+// 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 state2 = globalScheduler.getState();
+        if ((state2.queueLength ?? 0) > 0 && !state2.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();
+  for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {
+    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();
+}
+var init_utils = __esm({
+  "src/renderer/utils.ts"() {
+    init_scheduler();
+    init_logger();
+    init_diag();
+  }
+});
+
+// src/renderer/keyed.ts
+function getKeyMapForElement(el) {
+  return keyedElements.get(el);
+}
+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 {
+  }
+}
+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()) : [];
+  let moveCount = 0;
+  for (let i = 0; i < newKeyOrder.length; i++) {
+    const k = newKeyOrder[i];
+    if (i >= oldKeyOrder.length || oldKeyOrder[i] !== k || !oldKeyMap?.has(k)) {
+      moveCount++;
+    }
+  }
+  const FAST_MOVE_THRESHOLD_ABS = 64;
+  const FAST_MOVE_THRESHOLD_REL = 0.1;
+  const cheapMoveTrigger = totalKeyed >= 128 && oldKeyOrder.length > 0 && moveCount > Math.max(
+    FAST_MOVE_THRESHOLD_ABS,
+    Math.floor(totalKeyed * FAST_MOVE_THRESHOLD_REL)
+  );
+  let lisTrigger = false;
+  let lisLen = 0;
+  if (totalKeyed >= 128) {
+    const parentChildren = Array.from(parent.children);
+    const positions = keyedVnodes.map(({ key }) => {
+      const el = oldKeyMap?.get(key);
+      return el?.parentElement === parent ? parentChildren.indexOf(el) : -1;
+    });
+    lisLen = computeLISLength(positions);
+    lisTrigger = lisLen < Math.floor(totalKeyed * 0.5);
+  }
+  const hasPropsPresent = checkVnodesHaveProps(keyedVnodes);
+  const hasPropChanges = checkVnodePropChanges(keyedVnodes, oldKeyMap);
+  const useFastPath = (cheapMoveTrigger || lisTrigger) && !hasPropChanges && !hasPropsPresent;
+  return {
+    useFastPath,
+    totalKeyed,
+    moveCount,
+    lisLen,
+    hasPropChanges
+  };
+}
+var keyedElements, _reconcilerRecordedParents;
+var init_keyed = __esm({
+  "src/renderer/keyed.ts"() {
+    init_utils();
+    keyedElements = /* @__PURE__ */ new WeakMap();
+    _reconcilerRecordedParents = /* @__PURE__ */ new WeakSet();
+  }
+});
+
+// src/common/jsx.ts
+var ELEMENT_TYPE, Fragment;
+var init_jsx = __esm({
+  "src/common/jsx.ts"() {
+    ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("askr.element");
+    Fragment = /* @__PURE__ */ Symbol.for("askr.fragment");
+  }
+});
+
+// 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;
+  }
+}
+var init_dev_namespace = __esm({
+  "src/runtime/dev-namespace.ts"() {
+  }
+});
+
+// src/runtime/fastlane.ts
+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;
+}
+function markFastPathApplied(parent) {
+  if (!_appliedParents) return;
+  try {
+    _appliedParents.add(parent);
+  } catch (e) {
+  }
+}
+function isFastPathApplied(parent) {
+  return !!(_appliedParents && _appliedParents.has(parent));
+}
+function finalizeReadSubscriptions(instance) {
+  const newSet = instance._pendingReadStates ?? /* @__PURE__ */ new Set();
+  const oldSet = instance._lastReadStates ?? /* @__PURE__ */ new Set();
+  const token = instance._currentRenderToken;
+  if (token === void 0) return;
+  for (const s of oldSet) {
+    if (!newSet.has(s)) {
+      const readers = s._readers;
+      if (readers) readers.delete(instance);
+    }
+  }
+  instance.lastRenderToken = token;
+  for (const s of newSet) {
+    let readers = s._readers;
+    if (!readers) {
+      readers = /* @__PURE__ */ new Map();
+      s._readers = readers;
+    }
+    readers.set(instance, instance.lastRenderToken ?? 0);
+  }
+  instance._lastReadStates = newSet;
+  instance._pendingReadStates = /* @__PURE__ */ new Set();
+  instance._currentRenderToken = void 0;
+}
+function unwrapFragmentForFastPath(vnode) {
+  if (!vnode || typeof vnode !== "object" || !("type" in vnode)) return vnode;
+  const v = vnode;
+  if (typeof v.type === "symbol" && (v.type === Fragment || String(v.type) === "Symbol(askr.fragment)")) {
+    const children = v.children || v.props?.children;
+    if (Array.isArray(children) && children.length > 0) {
+      for (const child of children) {
+        if (child && typeof child === "object" && "type" in child) {
+          const c = child;
+          if (typeof c.type === "string") {
+            return child;
+          }
+        }
+      }
+    }
+  }
+  return vnode;
+}
+function classifyUpdate(instance, result) {
+  const unwrappedResult = unwrapFragmentForFastPath(result);
+  if (!unwrappedResult || typeof unwrappedResult !== "object" || !("type" in unwrappedResult))
+    return { useFastPath: false, reason: "not-vnode" };
+  const vnode = unwrappedResult;
+  if (vnode == null || typeof vnode.type !== "string")
+    return { useFastPath: false, reason: "not-intrinsic" };
+  const parent = instance.target;
+  if (!parent) return { useFastPath: false, reason: "no-root" };
+  const firstChild = parent.children[0];
+  if (!firstChild) return { useFastPath: false, reason: "no-first-child" };
+  if (firstChild.tagName.toLowerCase() !== String(vnode.type).toLowerCase())
+    return { useFastPath: false, reason: "root-tag-mismatch" };
+  const children = vnode.children || vnode.props?.children;
+  if (!Array.isArray(children))
+    return { useFastPath: false, reason: "no-children-array" };
+  for (const c of children) {
+    if (typeof c === "object" && c !== null && "type" in c && typeof c.type === "function") {
+      return { useFastPath: false, reason: "component-child-present" };
+    }
+  }
+  if (instance.mountOperations.length > 0)
+    return { useFastPath: false, reason: "pending-mounts" };
+  try {
+    populateKeyMapForElement(firstChild);
+  } catch {
+  }
+  const oldKeyMap = getKeyMapForElement(firstChild);
+  const decision = isKeyedReorderFastPathEligible(
+    firstChild,
+    children,
+    oldKeyMap
+  );
+  if (!decision.useFastPath || decision.totalKeyed < 128)
+    return { ...decision, useFastPath: false, reason: "renderer-declined" };
+  return { ...decision, useFastPath: true };
+}
+function commitReorderOnly(instance, result) {
+  const evaluate2 = globalThis.__ASKR_RENDERER?.evaluate;
+  if (typeof evaluate2 !== "function") {
+    logger.warn(
+      "[Tempo][FASTPATH][DEV] renderer.evaluate not available; declining fast-lane"
+    );
+    return false;
+  }
+  const schedBefore = process.env.NODE_ENV !== "production" ? globalScheduler.getState() : null;
+  enterBulkCommit();
+  try {
+    globalScheduler.runWithSyncProgress(() => {
+      evaluate2(result, instance.target);
+      try {
+        finalizeReadSubscriptions(instance);
+      } catch (e) {
+        if (process.env.NODE_ENV !== "production") throw e;
+      }
+    });
+    const clearedAfter = globalScheduler.clearPendingSyncTasks?.() ?? 0;
+    setDevValue("__FASTLANE_CLEARED_AFTER", clearedAfter);
+    if (process.env.NODE_ENV !== "production") {
+      validateFastLaneInvariants(instance, schedBefore);
+    }
+    return true;
+  } finally {
+    exitBulkCommit();
+  }
+  if (process.env.NODE_ENV !== "production") {
+    if (isBulkCommitActive2()) {
+      throw new Error(
+        "Fast-lane invariant violated: bulk commit flag still set after commit"
+      );
+    }
+  }
+}
+function validateFastLaneInvariants(instance, schedBefore) {
+  const commitCount = getDevValue("__LAST_FASTPATH_COMMIT_COUNT") ?? 0;
+  const invariants = {
+    commitCount,
+    mountOps: instance.mountOperations.length,
+    cleanupFns: instance.cleanupFns.length
+  };
+  setDevValue("__LAST_FASTLANE_INVARIANTS", invariants);
+  if (commitCount !== 1) {
+    console.error(
+      "[FASTLANE][INV] commitCount",
+      commitCount,
+      "diag",
+      globalThis.__ASKR_DIAG
+    );
+    throw new Error(
+      "Fast-lane invariant violated: expected exactly one DOM commit during reorder-only commit"
+    );
+  }
+  if (invariants.mountOps > 0) {
+    throw new Error(
+      "Fast-lane invariant violated: mount operations were registered during bulk commit"
+    );
+  }
+  if (invariants.cleanupFns > 0) {
+    throw new Error(
+      "Fast-lane invariant violated: cleanup functions were added during bulk commit"
+    );
+  }
+  const schedAfter = globalScheduler.getState();
+  if (schedBefore && schedAfter && schedAfter.taskCount > schedBefore.taskCount) {
+    console.error(
+      "[FASTLANE] schedBefore, schedAfter",
+      schedBefore,
+      schedAfter
+    );
+    console.error("[FASTLANE] enqueue logs", getDevValue("__ENQUEUE_LOGS"));
+    throw new Error(
+      "Fast-lane invariant violated: scheduler enqueued leftover work during bulk commit"
+    );
+  }
+  let finalState = globalScheduler.getState();
+  const executing = globalScheduler.isExecuting();
+  let outstandingAfter = Math.max(
+    0,
+    finalState.taskCount - (executing ? 1 : 0)
+  );
+  if (outstandingAfter !== 0) {
+    let attempts = 0;
+    while (attempts < 5) {
+      const cleared = globalScheduler.clearPendingSyncTasks?.() ?? 0;
+      if (cleared === 0) break;
+      attempts++;
+    }
+    finalState = globalScheduler.getState();
+    outstandingAfter = Math.max(
+      0,
+      finalState.taskCount - (globalScheduler.isExecuting() ? 1 : 0)
+    );
+    if (outstandingAfter !== 0) {
+      console.error(
+        "[FASTLANE] Post-commit enqueue logs:",
+        getDevValue("__ENQUEUE_LOGS")
+      );
+      console.error(
+        "[FASTLANE] Cleared counts:",
+        getDevValue("__FASTLANE_CLEARED_TASKS"),
+        getDevValue("__FASTLANE_CLEARED_AFTER")
+      );
+      throw new Error(
+        `Fast-lane invariant violated: scheduler has ${finalState.taskCount} pending task(s) after commit`
+      );
+    }
+  }
+}
+function tryRuntimeFastLaneSync(instance, result) {
+  const cls = classifyUpdate(instance, result);
+  if (!cls.useFastPath) {
+    setDevValue("__LAST_FASTPATH_STATS", void 0);
+    setDevValue("__LAST_FASTPATH_COMMIT_COUNT", 0);
+    return false;
+  }
+  try {
+    return commitReorderOnly(instance, result);
+  } catch (err) {
+    if (process.env.NODE_ENV !== "production") throw err;
+    return false;
+  }
+}
+var _bulkCommitActive, _appliedParents;
+var init_fastlane = __esm({
+  "src/runtime/fastlane.ts"() {
+    init_scheduler();
+    init_logger();
+    init_keyed();
+    init_jsx();
+    init_dev_namespace();
+    _bulkCommitActive = false;
+    _appliedParents = null;
+    if (typeof globalThis !== "undefined") {
+      globalThis.__ASKR_FASTLANE = {
+        isBulkCommitActive: isBulkCommitActive2,
+        enterBulkCommit,
+        exitBulkCommit,
+        tryRuntimeFastLaneSync,
+        markFastPathApplied,
+        isFastPathApplied
+      };
+    }
+  }
+});
+
+// src/common/vnode.ts
+function _isDOMElement(node) {
+  return typeof node === "object" && node !== null && "type" in node;
+}
+var init_vnode = __esm({
+  "src/common/vnode.ts"() {
+  }
+});
+
+// src/renderer/types.ts
+var init_types = __esm({
+  "src/renderer/types.ts"() {
+    init_vnode();
+  }
+});
+
+// src/renderer/cleanup.ts
+function cleanupSingleInstance(node, errors, strict) {
+  const inst = node.__ASKR_INSTANCE;
+  if (!inst) return;
+  try {
+    cleanupComponent(inst);
+  } catch (err) {
+    logger.warn("[Askr] cleanupComponent failed:", err);
+  }
+  try {
+    delete node.__ASKR_INSTANCE;
+  } catch (e) {
+  }
+}
+function forEachDescendantElement(root, visit) {
+  try {
+    const doc = root.ownerDocument;
+    const createTreeWalker = doc?.createTreeWalker;
+    if (typeof createTreeWalker === "function") {
+      const walker = createTreeWalker.call(doc, root, 1);
+      let n = walker.firstChild();
+      while (n) {
+        visit(n);
+        n = walker.nextNode();
+      }
+      return;
+    }
+  } catch {
+  }
+  const descendants = root.querySelectorAll("*");
+  for (let i = 0; i < descendants.length; i++) {
+    visit(descendants[i]);
+  }
+}
+function cleanupInstanceIfPresent(node, opts) {
+  if (!node || !(node instanceof Element)) return;
+  const strict = false;
+  const errors = null;
+  try {
+    cleanupSingleInstance(node, errors, strict);
+  } catch (err) {
+    logger.warn("[Askr] cleanupInstanceIfPresent failed:", err);
+  }
+  try {
+    forEachDescendantElement(node, (d) => {
+      try {
+        cleanupSingleInstance(d, errors, strict);
+      } catch (err) {
+        if (strict) ;
+        else
+          logger.warn(
+            "[Askr] cleanupInstanceIfPresent descendant cleanup failed:",
+            err
+          );
+      }
+    });
+  } catch (err) {
+    logger.warn(
+        "[Askr] cleanupInstanceIfPresent descendant query failed:",
+        err
+      );
+  }
+}
+function cleanupInstancesUnder(node, opts) {
+  cleanupInstanceIfPresent(node);
+}
+function removeElementListeners(element) {
+  const map = elementListeners.get(element);
+  if (map) {
+    for (const [eventName, entry] of map) {
+      if (entry.options !== void 0)
+        element.removeEventListener(eventName, entry.handler, entry.options);
+      else element.removeEventListener(eventName, entry.handler);
+    }
+    elementListeners.delete(element);
+  }
+}
+function removeAllListeners(root) {
+  if (!root) return;
+  removeElementListeners(root);
+  forEachDescendantElement(root, removeElementListeners);
+}
+var elementListeners;
+var init_cleanup = __esm({
+  "src/renderer/cleanup.ts"() {
+    init_component();
+    init_logger();
+    elementListeners = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// src/jsx/types.ts
+var init_types2 = __esm({
+  "src/jsx/types.ts"() {
+    init_jsx();
+  }
+});
+
+// src/jsx/jsx-runtime.ts
+var init_jsx_runtime = __esm({
+  "src/jsx/jsx-runtime.ts"() {
+    init_types2();
+  }
+});
+
+// src/renderer/dom.ts
+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) {
+  if (key === "value") {
+    if (tagNamesEqualIgnoreCase(tagName, "input") || tagNamesEqualIgnoreCase(tagName, "textarea") || tagNamesEqualIgnoreCase(tagName, "select")) {
+      el.value = String(value);
+      el.setAttribute("value", String(value));
+    } else {
+      el.setAttribute("value", String(value));
+    }
+  } else if (key === "checked") {
+    if (tagNamesEqualIgnoreCase(tagName, "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 {
+      }
+    }
+    return null;
+  }
+  if (typeof node === "string") {
+    return document.createTextNode(node);
+  }
+  if (typeof node === "number") {
+    return document.createTextNode(String(node));
+  }
+  if (!node) {
+    return null;
+  }
+  if (Array.isArray(node)) {
+    const fragment = document.createDocumentFragment();
+    for (const child of node) {
+      const dom = createDOMNode(child);
+      if (dom) fragment.appendChild(dom);
+    }
+    return fragment;
+  }
+  if (typeof node === "object" && node !== null && "type" in node) {
+    const type = node.type;
+    const props = node.props || {};
+    if (typeof type === "string") {
+      return createIntrinsicElement(node, type, props);
+    }
+    if (typeof type === "function") {
+      return createComponentElement(node, type, props);
+    }
+    if (typeof type === "symbol" && (type === Fragment || 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);
+      }
+    } 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);
+      }
+    } else {
+      const dom = createDOMNode(children);
+      if (dom) fragment.appendChild(dom);
+    }
+  }
+  return fragment;
+}
+function updateElementFromVnode(el, vnode, updateChildren = true) {
+  if (!_isDOMElement(vnode)) {
+    return;
+  }
+  const props = vnode.props || {};
+  materializeKey(el, vnode, props);
+  const existingListeners = elementListeners.get(el);
+  let desiredEventNames = null;
+  for (const key in props) {
+    const value = props[key];
+    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 (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);
+        }
+        existingListeners.delete(eventName);
+      } else {
+        el.removeAttribute(key);
+      }
+      continue;
+    }
+    if (key === "class" || key === "className") {
+      el.className = String(value);
+    } else if (key === "value" || key === "checked") {
+      el[key] = value;
+    } else if (eventName) {
+      if (existingListeners && existingListeners.size > 0) {
+        (desiredEventNames ??= /* @__PURE__ */ new Set()).add(eventName);
+      }
+      const existing = existingListeners?.get(eventName);
+      if (existing && existing.original === value) {
+        continue;
+      }
+      if (existing) {
+        if (existing.options !== void 0) {
+          el.removeEventListener(eventName, existing.handler, existing.options);
+        } else {
+          el.removeEventListener(eventName, existing.handler);
+        }
+      }
+      const wrappedHandler = createWrappedHandler(
+        value,
+        false
+      );
+      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: value,
+        options
+      });
+    } else {
+      el.setAttribute(key, String(value));
+    }
+  }
+  if (existingListeners && existingListeners.size > 0) {
+    if (desiredEventNames === null) {
+      for (const [eventName, entry] of existingListeners) {
+        if (entry.options !== void 0) {
+          el.removeEventListener(eventName, entry.handler, entry.options);
+        } else {
+          el.removeEventListener(eventName, entry.handler);
+        }
+      }
+      elementListeners.delete(el);
+    } else {
+      for (const [eventName, entry] of existingListeners) {
+        if (!desiredEventNames.has(eventName)) {
+          if (entry.options !== void 0) {
+            el.removeEventListener(eventName, entry.handler, entry.options);
+          } else {
+            el.removeEventListener(eventName, entry.handler);
+          }
+          existingListeners.delete(eventName);
+        }
+      }
+      if (existingListeners.size === 0) elementListeners.delete(el);
+    }
+  }
+  if (updateChildren) {
+    const children = vnode.children || props.children;
+    updateElementChildren(el, children);
+  }
+}
+function updateElementChildren(el, children) {
+  if (!children) {
+    el.textContent = "";
+    return;
+  }
+  if (!Array.isArray(children) && (typeof children === "string" || typeof children === "number")) {
+    if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
+      el.firstChild.data = String(children);
+    } else {
+      el.textContent = String(children);
+    }
+    return;
+  }
+  if (Array.isArray(children)) {
+    updateUnkeyedChildren(el, children);
+    return;
+  }
+  el.textContent = "";
+  const dom = createDOMNode(children);
+  if (dom) el.appendChild(dom);
+}
+function updateUnkeyedChildren(parent, newChildren) {
+  const existing = Array.from(parent.children);
+  if (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 = "";
+  }
+  const max = Math.max(existing.length, newChildren.length);
+  for (let i = 0; i < max; i++) {
+    const current = existing[i];
+    const next = newChildren[i];
+    if (next === void 0 && current) {
+      cleanupInstanceIfPresent(current);
+      current.remove();
+      continue;
+    }
+    if (!current && next !== void 0) {
+      const dom = createDOMNode(next);
+      if (dom) parent.appendChild(dom);
+      continue;
+    }
+    if (!current || next === void 0) continue;
+    if (typeof next === "string" || typeof next === "number") {
+      current.textContent = String(next);
+    } else if (_isDOMElement(next)) {
+      if (typeof next.type === "string") {
+        if (tagsEqualIgnoreCase(current.tagName, next.type)) {
+          updateElementFromVnode(current, next);
+        } else {
+          const dom = createDOMNode(next);
+          if (dom) {
+            if (current instanceof Element) removeAllListeners(current);
+            cleanupInstanceIfPresent(current);
+            parent.replaceChild(dom, current);
+          }
+        }
+      } else {
+        const dom = createDOMNode(next);
+        if (dom) {
+          if (current instanceof Element) removeAllListeners(current);
+          cleanupInstanceIfPresent(current);
+          parent.replaceChild(dom, current);
+        }
+      }
+    } else {
+      const dom = createDOMNode(next);
+      if (dom) {
+        if (current instanceof Element) removeAllListeners(current);
+        cleanupInstanceIfPresent(current);
+        parent.replaceChild(dom, current);
+      }
+    }
+  }
+}
+function performBulkPositionalKeyedTextUpdate(parent, keyedVnodes) {
+  const total = keyedVnodes.length;
+  let reused = 0;
+  let updatedKeys = 0;
+  const t0 = now();
+  const debugFastPath = process.env.ASKR_FASTPATH_DEBUG === "1" || process.env.ASKR_FASTPATH_DEBUG === "true";
+  for (let i = 0; i < total; i++) {
+    const { key, vnode } = keyedVnodes[i];
+    const ch = parent.children[i];
+    if (ch && _isDOMElement(vnode) && typeof vnode.type === "string") {
+      const vnodeType = vnode.type;
+      if (tagsEqualIgnoreCase(ch.tagName, vnodeType)) {
+        const children = vnode.children || vnode.props?.children;
+        if (debugFastPath) {
+          logFastPathDebug("positional idx", i, {
+            chTag: ch.tagName,
+            vnodeType,
+            chChildNodes: ch.childNodes.length,
+            childrenType: Array.isArray(children) ? "array" : typeof children
+          });
+        }
+        updateTextContent(ch, children, vnode);
+        setDataKey(ch, key, () => updatedKeys++);
+        reused++;
+        continue;
+      } else {
+        if (debugFastPath) {
+          logFastPathDebug("positional tag mismatch", i, {
+            chTag: ch.tagName,
+            vnodeType
+          });
+        }
+      }
+    } else {
+      if (debugFastPath) {
+        logFastPathDebug("positional missing or invalid", i, { ch: !!ch });
+      }
+    }
+    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, vnode) {
+  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 {
+    if (!tryUpdateTwoChildTextPattern(el, vnode)) {
+      updateElementFromVnode(el, vnode);
+    }
+  }
+}
+function tryUpdateTwoChildTextPattern(parentEl, vnode) {
+  const vnodeChildren = vnode.children || vnode.props?.children;
+  if (!Array.isArray(vnodeChildren) || vnodeChildren.length !== 2) return false;
+  const c0 = vnodeChildren[0];
+  const c1 = vnodeChildren[1];
+  if (!_isDOMElement(c0) || !_isDOMElement(c1)) return false;
+  if (typeof c0.type !== "string" || typeof c1.type !== "string") return false;
+  const el0 = parentEl.children[0];
+  const el1 = parentEl.children[1];
+  if (!el0 || !el1) return false;
+  if (!tagsEqualIgnoreCase(el0.tagName, c0.type)) return false;
+  if (!tagsEqualIgnoreCase(el1.tagName, c1.type)) return false;
+  const t0 = c0.children || c0.props?.children;
+  const t1 = c1.children || c1.props?.children;
+  if (typeof t0 === "string" || typeof t0 === "number") {
+    setTextNodeData(el0, String(t0));
+  } else if (Array.isArray(t0) && t0.length === 1 && (typeof t0[0] === "string" || typeof t0[0] === "number")) {
+    setTextNodeData(el0, String(t0[0]));
+  } else {
+    return false;
+  }
+  if (typeof t1 === "string" || typeof t1 === "number") {
+    setTextNodeData(el1, String(t1));
+  } else if (Array.isArray(t1) && t1.length === 1 && (typeof t1[0] === "string" || typeof t1[0] === "number")) {
+    setTextNodeData(el1, String(t1[0]));
+  } else {
+    return false;
+  }
+  return true;
+}
+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 {
+    const next = String(key);
+    if (el.getAttribute("data-key") === next) return;
+    el.setAttribute("data-key", next);
+    onSet();
+  } catch {
+  }
+}
+function upperCommonTagName(tag) {
+  switch (tag) {
+    case "div":
+      return "DIV";
+    case "span":
+      return "SPAN";
+    case "p":
+      return "P";
+    case "a":
+      return "A";
+    case "button":
+      return "BUTTON";
+    case "input":
+      return "INPUT";
+    case "ul":
+      return "UL";
+    case "ol":
+      return "OL";
+    case "li":
+      return "LI";
+    default:
+      return null;
+  }
+}
+function tagNamesEqualIgnoreCase(a, b) {
+  if (a === b) return true;
+  const len = a.length;
+  if (len !== b.length) return false;
+  for (let i = 0; i < len; i++) {
+    const ac = a.charCodeAt(i);
+    const bc = b.charCodeAt(i);
+    if (ac === bc) continue;
+    const an = ac >= 65 && ac <= 90 ? ac + 32 : ac;
+    const bn = bc >= 65 && bc <= 90 ? bc + 32 : bc;
+    if (an !== bn) return false;
+  }
+  return true;
+}
+function tagsEqualIgnoreCase(elementTagName, vnodeType) {
+  const upperCommon = upperCommonTagName(vnodeType);
+  if (upperCommon !== null && elementTagName === upperCommon) return true;
+  return tagNamesEqualIgnoreCase(elementTagName, vnodeType);
+}
+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);
+    }
+  }
+}
+function updateKeyedElementsMap(parent, keyedVnodes) {
+  try {
+    const existing = keyedElements.get(parent);
+    const newKeyMap = existing ? (existing.clear(), existing) : /* @__PURE__ */ new Map();
+    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 {
+  }
+}
+function performBulkTextReplace(parent, newChildren) {
+  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 result = processChildNode(newChildren[i], existing[i], finalNodes);
+    if (result === "reused") reused++;
+    else if (result === "created") created++;
+  }
+  const tBuild = now() - t0;
+  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 && tagsEqualIgnoreCase(existingNode.tagName, tag)) {
+      updateElementFromVnode(existingNode, vnode);
+      finalNodes.push(existingNode);
+      return "reused";
+    }
+  }
+  const dom = createDOMNode(vnode);
+  if (dom) {
+    finalNodes.push(dom);
+    return "created";
+  }
+  return "skipped";
+}
+function commitBulkReplace(parent, nodes) {
+  const fragStart = Date.now();
+  const fragment = document.createDocumentFragment();
+  for (let i = 0; i < nodes.length; i++) {
+    fragment.appendChild(nodes[i]);
+  }
+  try {
+    for (let n = parent.firstChild; n; ) {
+      const next = n.nextSibling;
+      if (n instanceof Element) removeAllListeners(n);
+      cleanupInstanceIfPresent(n);
+      n = next;
+    }
+  } catch {
+  }
+  recordDOMReplace("bulk-text-replace");
+  parent.replaceChildren(fragment);
+  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 {
+  }
+}
+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) {
+    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 < children.length; i++) {
+    const c = children[i];
+    if (typeof c === "string" || typeof c === "number") {
+      simple++;
+      continue;
+    }
+    if (typeof c === "object" && c !== null && "type" in c) {
+      const dv = c;
+      if (typeof dv.type === "function") {
+        return { simple, componentFound: i };
+      }
+      if (typeof dv.type === "string" && isSimpleElement(dv)) {
+        simple++;
+      }
+    }
+  }
+  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", data);
+    } catch {
+    }
+  }
+}
+var IS_DOM_AVAILABLE;
+var init_dom = __esm({
+  "src/renderer/dom.ts"() {
+    init_logger();
+    init_jsx_runtime();
+    init_context();
+    init_component();
+    init_cleanup();
+    init_diag();
+    init_types();
+    init_keyed();
+    init_utils();
+    IS_DOM_AVAILABLE = typeof document !== "undefined";
+  }
+});
+
+// src/renderer/fastpath.ts
+function applyRendererFastPath(parent, keyedVnodes, oldKeyMap, unkeyedVnodes) {
+  if (typeof document === "undefined") return null;
+  const totalKeyed = keyedVnodes.length;
+  if (totalKeyed === 0 && (!unkeyedVnodes || unkeyedVnodes.length === 0))
+    return null;
+  if (!isSchedulerExecuting()) {
+    logger.warn(
+      "[Askr][FASTPATH][DEV] Fast-path reconciliation invoked outside scheduler execution"
+    );
+  }
+  let parentChildrenArr;
+  let localOldKeyMap;
+  if (totalKeyed <= 20) {
+    try {
+      const pc = parent.children;
+      parentChildrenArr = new Array(pc.length);
+      for (let i = 0; i < pc.length; i++)
+        parentChildrenArr[i] = pc[i];
+    } catch (e) {
+      parentChildrenArr = void 0;
+    }
+  } else {
+    localOldKeyMap = /* @__PURE__ */ new Map();
+    try {
+      for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {
+        const k = ch.getAttribute("data-key");
+        if (k !== null) {
+          localOldKeyMap.set(k, ch);
+          const n = Number(k);
+          if (!Number.isNaN(n)) localOldKeyMap.set(n, ch);
+        }
+      }
+    } catch (e) {
+      localOldKeyMap = void 0;
+    }
+  }
+  const finalNodes = [];
+  let mapLookups = 0;
+  let createdNodes = 0;
+  let reusedCount = 0;
+  for (let i = 0; i < keyedVnodes.length; i++) {
+    const { key, vnode } = keyedVnodes[i];
+    mapLookups++;
+    let el;
+    if (totalKeyed <= 20 && parentChildrenArr) {
+      const ks = String(key);
+      for (let j = 0; j < parentChildrenArr.length; j++) {
+        const ch = parentChildrenArr[j];
+        const k = ch.getAttribute("data-key");
+        if (k !== null && (k === ks || Number(k) === key)) {
+          el = ch;
+          break;
+        }
+      }
+      if (!el) el = oldKeyMap?.get(key);
+    } else {
+      el = localOldKeyMap?.get(key) ?? oldKeyMap?.get(key);
+    }
+    if (el) {
+      finalNodes.push(el);
+      reusedCount++;
+    } else {
+      const newEl = createDOMNode(vnode);
+      if (newEl) {
+        finalNodes.push(newEl);
+        createdNodes++;
+      }
+    }
+  }
+  if (unkeyedVnodes && unkeyedVnodes.length) {
+    for (const vnode of unkeyedVnodes) {
+      const newEl = createDOMNode(vnode);
+      if (newEl) {
+        finalNodes.push(newEl);
+        createdNodes++;
+      }
+    }
+  }
+  try {
+    const tFragmentStart = Date.now();
+    const fragment = document.createDocumentFragment();
+    let fragmentAppendCount = 0;
+    for (let i = 0; i < finalNodes.length; i++) {
+      fragment.appendChild(finalNodes[i]);
+      fragmentAppendCount++;
+    }
+    try {
+      for (let n = parent.firstChild; n; ) {
+        const next = n.nextSibling;
+        if (n instanceof Element) removeAllListeners(n);
+        cleanupInstanceIfPresent(n);
+        n = next;
+      }
+    } catch (e) {
+      void e;
+    }
+    try {
+      __ASKR_incCounter("__DOM_REPLACE_COUNT");
+      __ASKR_set("__LAST_DOM_REPLACE_STACK_FASTPATH", new Error().stack);
+    } catch (e) {
+      void e;
+    }
+    parent.replaceChildren(fragment);
+    try {
+      __ASKR_set("__LAST_FASTPATH_COMMIT_COUNT", 1);
+    } catch (e) {
+      void e;
+    }
+    try {
+      if (isBulkCommitActive2()) markFastPathApplied(parent);
+    } catch (e) {
+      void e;
+    }
+    const newKeyMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < keyedVnodes.length; i++) {
+      const key = keyedVnodes[i].key;
+      const node = finalNodes[i];
+      if (node instanceof Element) newKeyMap.set(key, node);
+    }
+    try {
+      const stats = {
+        n: totalKeyed,
+        moves: 0,
+        lisLen: 0,
+        t_lookup: 0,
+        t_fragment: Date.now() - tFragmentStart,
+        t_commit: 0,
+        t_bookkeeping: 0,
+        fragmentAppendCount,
+        mapLookups,
+        createdNodes,
+        reusedCount
+      };
+      if (typeof globalThis !== "undefined") {
+        __ASKR_set("__LAST_FASTPATH_STATS", stats);
+        __ASKR_set("__LAST_FASTPATH_REUSED", reusedCount > 0);
+        __ASKR_incCounter("fastpathHistoryPush");
+      }
+      if (process.env.ASKR_FASTPATH_DEBUG === "1" || process.env.ASKR_FASTPATH_DEBUG === "true") {
+        logger.warn(
+          "[Askr][FASTPATH]",
+          JSON.stringify({ n: totalKeyed, createdNodes, reusedCount })
+        );
+      }
+    } catch (e) {
+      void e;
+    }
+    try {
+      _reconcilerRecordedParents.add(parent);
+    } catch (e) {
+      void e;
+    }
+    return newKeyMap;
+  } catch (e) {
+    return null;
+  }
+}
+var init_fastpath = __esm({
+  "src/renderer/fastpath.ts"() {
+    init_dom();
+    init_keyed();
+    init_logger();
+    init_cleanup();
+    init_diag();
+    init_scheduler();
+    init_fastlane();
+  }
+});
+
+// src/renderer/reconcile.ts
+function tagNamesEqualIgnoreCase2(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const ca = a.charCodeAt(i);
+    const cb = b.charCodeAt(i);
+    if (ca === cb) continue;
+    const fa = ca >= 65 && ca <= 90 ? ca + 32 : ca;
+    const fb = cb >= 65 && cb <= 90 ? cb + 32 : cb;
+    if (fa !== fb) return false;
+  }
+  return true;
+}
+function reconcileKeyedChildren(parent, newChildren, oldKeyMap) {
+  const { keyedVnodes, unkeyedVnodes } = partitionChildren(newChildren);
+  const fastPathResult = tryFastPaths(
+    parent,
+    newChildren,
+    keyedVnodes,
+    unkeyedVnodes,
+    oldKeyMap
+  );
+  if (fastPathResult) return fastPathResult;
+  return performFullReconciliation(parent, newChildren, keyedVnodes, oldKeyMap);
+}
+function partitionChildren(newChildren) {
+  const keyedVnodes = [];
+  const unkeyedVnodes = [];
+  for (let i = 0; i < newChildren.length; i++) {
+    const child = newChildren[i];
+    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 rendererResult = tryRendererFastPath(
+      parent,
+      newChildren,
+      keyedVnodes,
+      unkeyedVnodes,
+      oldKeyMap
+    );
+    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);
+  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 (tagNamesEqualIgnoreCase2(el.tagName, vnode.type)) {
+        matchCount++;
+      }
+    }
+  } catch {
+  }
+  return matchCount;
+}
+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 {
+    return true;
+  }
+  return false;
+}
+function rebuildKeyedMap(parent) {
+  try {
+    const map = /* @__PURE__ */ new Map();
+    for (let el = parent.firstElementChild; el; el = el.nextElementSibling) {
+      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 {
+    for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {
+      if (usedOldEls.has(ch)) continue;
+      const attr = ch.getAttribute("data-key");
+      if (attr === keyStr) {
+        usedOldEls.add(ch);
+        return ch;
+      }
+      if (attr !== null) {
+        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) {
+    try {
+      const childObj = child;
+      if (childObj && typeof childObj === "object" && typeof childObj.type === "string") {
+        if (tagNamesEqualIgnoreCase2(el.tagName, childObj.type)) {
+          updateElementFromVnode(el, child);
+          newKeyMap.set(key, el);
+          return el;
+        }
+      }
+    } catch {
+    }
+  }
+  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 existingKey = existing.getAttribute("data-key");
+  const hasNoKey = existingKey === null || existingKey === void 0;
+  return hasNoKey && typeof childObj.type === "string" && tagNamesEqualIgnoreCase2(existing.tagName, childObj.type);
+}
+function findAvailableUnkeyedElement(parent, usedOldEls) {
+  for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {
+    if (usedOldEls.has(ch)) continue;
+    if (ch.getAttribute("data-key") === null) return ch;
+  }
+  return void 0;
+}
+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" && tagNamesEqualIgnoreCase2(avail.tagName, childObj.type)) {
+      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 {
+    for (let n = parent.firstChild; n; ) {
+      const next = n.nextSibling;
+      if (n instanceof Element) removeAllListeners(n);
+      cleanupInstanceIfPresent(n);
+      n = next;
+    }
+  } catch {
+  }
+  recordDOMReplace("reconcile");
+  parent.replaceChildren(fragment);
+}
+var init_reconcile = __esm({
+  "src/renderer/reconcile.ts"() {
+    init_dom();
+    init_keyed();
+    init_cleanup();
+    init_fastlane();
+    init_fastpath();
+    init_utils();
+  }
+});
+
+// src/renderer/evaluate.ts
+function tagNamesEqualIgnoreCase3(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const ca = a.charCodeAt(i);
+    const cb = b.charCodeAt(i);
+    if (ca === cb) continue;
+    const fa = ca >= 65 && ca <= 90 ? ca + 32 : ca;
+    const fb = cb >= 65 && cb <= 90 ? cb + 32 : cb;
+    if (fa !== fb) return false;
+  }
+  return true;
+}
+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();
+  for (let child = parent.firstElementChild; child; child = child.nextElementSibling) {
+    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) {
+  for (let i = 0; i < children.length; i++) {
+    if (extractKey(children[i]) !== void 0) return true;
+  }
+  return false;
+}
+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 {
+    }
+  }
+}
+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
+        });
+      }
+    }
+    if (keyedVnodes.length === 0 || keyedVnodes.length !== children.length) {
+      return false;
+    }
+    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 {
+      reconcileKeyed(element, vnodeChildren, oldKeyMap);
+    } catch {
+      const newKeyMap = reconcileKeyedChildren(
+        element,
+        vnodeChildren,
+        oldKeyMap
+      );
+      keyedElements.set(element, newKeyMap);
+    }
+  } 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) {
+  let existingNode = target.firstElementChild;
+  for (let i = 0; i < childArray.length; i++) {
+    const childVnode = childArray[i];
+    const nextExisting = existingNode ? existingNode.nextElementSibling : null;
+    if (existingNode && _isDOMElement(childVnode) && typeof childVnode.type === "string" && tagNamesEqualIgnoreCase3(
+      existingNode.tagName,
+      childVnode.type
+    )) {
+      smartUpdateElement(existingNode, childVnode);
+      existingNode = nextExisting;
+      continue;
+    }
+    const newDom = createDOMNode(childVnode);
+    if (newDom) {
+      if (existingNode) {
+        target.replaceChild(newDom, existingNode);
+      } else {
+        target.appendChild(newDom);
+      }
+    }
+    existingNode = nextExisting;
+  }
+  while (existingNode) {
+    const next = existingNode.nextElementSibling;
+    target.removeChild(existingNode);
+    existingNode = next;
+  }
+}
+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;
+    const eventName = parseEventName(key);
+    if (eventName) {
+      const wrappedHandler = createWrappedHandler(
+        value,
+        false
+      );
+      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: 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));
+    }
+  }
+}
+function tryFirstRenderKeyedChildren(target, vnode) {
+  const children = vnode.children;
+  if (!Array.isArray(children) || !hasKeyedChildren(children)) {
+    return false;
+  }
+  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") {
+    if (process.env.NODE_ENV !== "production") {
+      try {
+        console.warn("[Askr] evaluate() called in non-DOM environment; no-op.");
+      } catch (e) {
+      }
+    }
+    return;
+  }
+  if (context && domRanges.has(context)) {
+    const range = domRanges.get(context);
+    let current = range.start.nextSibling;
+    while (current && current !== range.end) {
+      const next = current.nextSibling;
+      current.remove();
+      current = next;
+    }
+    const dom = createDOMNode(node);
+    if (dom) {
+      target.insertBefore(dom, range.end);
+    }
+  } else if (context) {
+    const start = document.createComment("component-start");
+    const end = document.createComment("component-end");
+    target.appendChild(start);
+    target.appendChild(end);
+    domRanges.set(context, { start, end });
+    const dom = createDOMNode(node);
+    if (dom) {
+      target.insertBefore(dom, end);
+    }
+  } else {
+    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 {
+        processFragmentChildren(target, childArray);
+        return;
+      }
+    }
+    const firstChild = target.children[0];
+    if (firstChild && _isDOMElement(vnode) && typeof vnode.type === "string" && tagNamesEqualIgnoreCase3(firstChild.tagName, vnode.type)) {
+      smartUpdateElement(firstChild, vnode);
+    } else {
+      target.textContent = "";
+      if (_isDOMElement(vnode) && typeof vnode.type === "string" && tryFirstRenderKeyedChildren(target, vnode)) {
+        return;
+      }
+      const dom = createDOMNode(vnode);
+      if (dom) {
+        target.appendChild(dom);
+      }
+    }
+  }
+}
+var domRanges;
+var init_evaluate = __esm({
+  "src/renderer/evaluate.ts"() {
+    init_logger();
+    init_cleanup();
+    init_keyed();
+    init_reconcile();
+    init_types();
+    init_dom();
+    init_diag();
+    init_jsx();
+    init_utils();
+    domRanges = /* @__PURE__ */ new WeakMap();
+  }
+});
+
+// src/renderer/index.ts
+var init_renderer = __esm({
+  "src/renderer/index.ts"() {
+    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
+      };
+    }
+  }
+});
+
+// src/runtime/component.ts
+function createComponentInstance(id, fn, props, target) {
+  const instance = {
+    id,
+    fn,
+    props,
+    target,
+    mounted: false,
+    abortController: new AbortController(),
+    // Create per-component
+    stateValues: [],
+    evaluationGeneration: 0,
+    notifyUpdate: null,
+    // Prebound helpers (initialized below) to avoid per-update allocations
+    _pendingFlushTask: void 0,
+    _pendingRunTask: void 0,
+    _enqueueRun: void 0,
+    stateIndexCheck: -1,
+    expectedStateIndices: [],
+    firstRenderComplete: false,
+    mountOperations: [],
+    cleanupFns: [],
+    hasPendingUpdate: false,
+    ownerFrame: null,
+    // Will be set by renderer when vnode is marked
+    ssr: false,
+    cleanupStrict: false,
+    isRoot: false,
+    // Render-tracking (for precise state subscriptions)
+    _currentRenderToken: void 0,
+    lastRenderToken: 0,
+    _pendingReadStates: /* @__PURE__ */ new Set(),
+    _lastReadStates: /* @__PURE__ */ new Set()
+  };
+  instance._pendingRunTask = () => {
+    instance.hasPendingUpdate = false;
+    runComponent(instance);
+  };
+  instance._enqueueRun = () => {
+    if (!instance.hasPendingUpdate) {
+      instance.hasPendingUpdate = true;
+      globalScheduler.enqueue(instance._pendingRunTask);
+    }
+  };
+  instance._pendingFlushTask = () => {
+    instance.hasPendingUpdate = false;
+    instance._enqueueRun?.();
+  };
+  return instance;
+}
+function getCurrentComponentInstance() {
+  return currentInstance;
+}
+function executeMountOperations(instance) {
+  if (!instance.isRoot) return;
+  for (const operation of instance.mountOperations) {
+    const result = operation();
+    if (result instanceof Promise) {
+      result.then((cleanup) => {
+        if (typeof cleanup === "function") {
+          instance.cleanupFns.push(cleanup);
+        }
+      });
+    } else if (typeof result === "function") {
+      instance.cleanupFns.push(result);
+    }
+  }
+  instance.mountOperations = [];
+}
+function mountInstanceInline(instance, target) {
+  instance.target = target;
+  try {
+    if (target instanceof Element)
+      target.__ASKR_INSTANCE = instance;
+  } catch (err) {
+  }
+  instance.notifyUpdate = instance._enqueueRun;
+  const wasFirstMount = !instance.mounted;
+  instance.mounted = true;
+  if (wasFirstMount && instance.mountOperations.length > 0) {
+    executeMountOperations(instance);
+  }
+}
+function runComponent(instance) {
+  instance.notifyUpdate = instance._enqueueRun;
+  instance._currentRenderToken = ++_globalRenderCounter;
+  instance._pendingReadStates = /* @__PURE__ */ new Set();
+  const domSnapshot = instance.target ? instance.target.innerHTML : "";
+  const result = executeComponentSync(instance);
+  if (result instanceof Promise) {
+    throw new Error(
+      "Async components are not supported. Components must be synchronous."
+    );
+  } else {
+    const fastlaneBridge = globalThis.__ASKR_FASTLANE;
+    try {
+      const used = fastlaneBridge?.tryRuntimeFastLaneSync?.(instance, result);
+      if (used) return;
+    } catch (err) {
+      if (process.env.NODE_ENV !== "production") throw err;
+    }
+    globalScheduler.enqueue(() => {
+      if (!instance.target && instance._placeholder) {
+        if (result === null || result === void 0) {
+          finalizeReadSubscriptions2(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;
+          finalizeReadSubscriptions2(instance);
+        } finally {
+          currentInstance = oldInstance;
+        }
+        return;
+      }
+      if (instance.target) {
+        let oldChildren = [];
+        try {
+          const wasFirstMount = !instance.mounted;
+          const oldInstance = currentInstance;
+          currentInstance = instance;
+          oldChildren = Array.from(instance.target.childNodes);
+          try {
+            evaluate(result, instance.target);
+          } catch (e) {
+            try {
+              const newChildren = Array.from(instance.target.childNodes);
+              for (const n of newChildren) {
+                try {
+                  cleanupInstancesUnder(n);
+                } catch (err) {
+                  logger.warn(
+                    "[Askr] error cleaning up failed commit children:",
+                    err
+                  );
+                }
+              }
+            } catch (_err) {
+              void _err;
+            }
+            try {
+              __ASKR_incCounter("__DOM_REPLACE_COUNT");
+              __ASKR_set(
+                "__LAST_DOM_REPLACE_STACK_COMPONENT_RESTORE",
+                new Error().stack
+              );
+            } catch (e2) {
+              void e2;
+            }
+            instance.target.replaceChildren(...oldChildren);
+            throw e;
+          } finally {
+            currentInstance = oldInstance;
+          }
+          finalizeReadSubscriptions2(instance);
+          instance.mounted = true;
+          if (wasFirstMount && instance.mountOperations.length > 0) {
+            executeMountOperations(instance);
+          }
+        } catch (renderError) {
+          try {
+            const currentChildren = Array.from(instance.target.childNodes);
+            for (const n of currentChildren) {
+              try {
+                cleanupInstancesUnder(n);
+              } catch (err) {
+                logger.warn(
+                  "[Askr] error cleaning up partial children during rollback:",
+                  err
+                );
+              }
+            }
+          } catch (_err) {
+          }
+          try {
+            try {
+              __ASKR_incCounter("__DOM_REPLACE_COUNT");
+              __ASKR_set(
+                "__LAST_DOM_REPLACE_STACK_COMPONENT_ROLLBACK",
+                new Error().stack
+              );
+            } catch (e) {
+              void e;
+            }
+            instance.target.replaceChildren(...oldChildren);
+          } catch {
+            instance.target.innerHTML = domSnapshot;
+          }
+          throw renderError;
+        }
+      }
+    });
+  }
+}
+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();
+  }
+  try {
+    const result = executeComponentSync(instance);
+    if (!hadToken) {
+      finalizeReadSubscriptions2(instance);
+    }
+    return result;
+  } finally {
+    instance._currentRenderToken = prevToken;
+    instance._pendingReadStates = prevPendingReads ?? /* @__PURE__ */ new Set();
+  }
+}
+function executeComponentSync(instance) {
+  instance.stateIndexCheck = -1;
+  for (const state2 of instance.stateValues) {
+    if (state2) {
+      state2._hasBeenRead = false;
+    }
+  }
+  instance._pendingReadStates = /* @__PURE__ */ new Set();
+  currentInstance = instance;
+  stateIndex = 0;
+  try {
+    const renderStartTime = process.env.NODE_ENV !== "production" ? Date.now() : 0;
+    const context = {
+      signal: instance.abortController.signal
+    };
+    const executionFrame = {
+      parent: instance.ownerFrame,
+      values: null
+    };
+    const result = withContext(
+      executionFrame,
+      () => instance.fn(instance.props, context)
+    );
+    const renderTime = Date.now() - renderStartTime;
+    if (renderTime > 5) {
+      logger.warn(
+        `[askr] Slow render detected: ${renderTime}ms. Consider optimizing component performance.`
+      );
+    }
+    if (!instance.firstRenderComplete) {
+      instance.firstRenderComplete = true;
+    }
+    for (let i = 0; i < instance.stateValues.length; i++) {
+      const state2 = instance.stateValues[i];
+      if (state2 && !state2._hasBeenRead) {
+        try {
+          const name = instance.fn?.name || "<anonymous>";
+          logger.warn(
+            `[askr] Unused state variable detected in ${name} at index ${i}. State should be read during render or removed.`
+          );
+        } catch {
+          logger.warn(
+            `[askr] Unused state variable detected. State should be read during render or removed.`
+          );
+        }
+      }
+    }
+    return result;
+  } finally {
+    currentInstance = null;
+  }
+}
+function executeComponent(instance) {
+  instance.abortController = new AbortController();
+  instance.notifyUpdate = instance._enqueueRun;
+  globalScheduler.enqueue(() => runComponent(instance));
+}
+function getCurrentInstance() {
+  return currentInstance;
+}
+function finalizeReadSubscriptions2(instance) {
+  const newSet = instance._pendingReadStates ?? /* @__PURE__ */ new Set();
+  const oldSet = instance._lastReadStates ?? /* @__PURE__ */ new Set();
+  const token = instance._currentRenderToken;
+  if (token === void 0) return;
+  for (const s of oldSet) {
+    if (!newSet.has(s)) {
+      const readers = s._readers;
+      if (readers) readers.delete(instance);
+    }
+  }
+  instance.lastRenderToken = token;
+  for (const s of newSet) {
+    let readers = s._readers;
+    if (!readers) {
+      readers = /* @__PURE__ */ new Map();
+      s._readers = readers;
+    }
+    readers.set(instance, instance.lastRenderToken ?? 0);
+  }
+  instance._lastReadStates = newSet;
+  instance._pendingReadStates = /* @__PURE__ */ new Set();
+  instance._currentRenderToken = void 0;
+}
+function getNextStateIndex() {
+  return stateIndex++;
+}
+function mountComponent(instance) {
+  executeComponent(instance);
+}
+function cleanupComponent(instance) {
+  const cleanupErrors = [];
+  for (const cleanup of instance.cleanupFns) {
+    try {
+      cleanup();
+    } catch (err) {
+      if (instance.cleanupStrict) {
+        cleanupErrors.push(err);
+      } else {
+        if (process.env.NODE_ENV !== "production") {
+          logger.warn("[Askr] cleanup function threw:", err);
+        }
+      }
+    }
+  }
+  instance.cleanupFns = [];
+  if (cleanupErrors.length > 0) {
+    throw new AggregateError(
+      cleanupErrors,
+      `Cleanup failed for component ${instance.id}`
+    );
+  }
+  if (instance._lastReadStates) {
+    for (const s of instance._lastReadStates) {
+      const readers = s._readers;
+      if (readers) readers.delete(instance);
+    }
+    instance._lastReadStates = /* @__PURE__ */ new Set();
+  }
+  instance.abortController.abort();
+  instance.notifyUpdate = null;
+  instance.mounted = false;
+}
+var currentInstance, stateIndex, _globalRenderCounter;
+var init_component = __esm({
+  "src/runtime/component.ts"() {
+    init_scheduler();
+    init_context();
+    init_logger();
+    init_diag();
+    init_renderer();
+    currentInstance = null;
+    stateIndex = 0;
+    _globalRenderCounter = 0;
+  }
+});
+
+// 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 };
+}
+var init_match = __esm({
+  "src/router/match.ts"() {
+  }
+});
+
+// src/runtime/execution-model.ts
+function getExecutionModel() {
+  const g = globalThis;
+  return g[EXECUTION_MODEL_KEY];
+}
+function assertExecutionModel(model) {
+  const g = globalThis;
+  const cur = g[EXECUTION_MODEL_KEY];
+  if (cur && cur !== model) {
+    throw new Error(
+      `[Askr] mixing execution models is not allowed (current: ${cur}, attempted: ${model}). Choose exactly one: createSPA, createSSR, or createIslands.`
+    );
+  }
+  if (!cur) g[EXECUTION_MODEL_KEY] = model;
+}
+var EXECUTION_MODEL_KEY;
+var init_execution_model = __esm({
+  "src/runtime/execution-model.ts"() {
+    EXECUTION_MODEL_KEY = /* @__PURE__ */ Symbol.for("__ASKR_EXECUTION_MODEL__");
+  }
+});
+
+// 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
+});
+function setHasRoutes(value) {
+  try {
+    const g = globalThis;
+    g[HAS_ROUTES_KEY] = value;
+  } catch {
+  }
+}
+function getDepth(path) {
+  const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+  return normalized === "/" ? 0 : normalized.split("/").filter(Boolean).length;
+}
+function getSpecificity(path) {
+  const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+  if (normalized === "/*") {
+    return 0;
+  }
+  const segments = normalized.split("/").filter(Boolean);
+  let score = 0;
+  for (const segment of segments) {
+    if (segment.startsWith("{") && segment.endsWith("}")) {
+      score += 2;
+    } else if (segment === "*") {
+      score += 1;
+    } else {
+      score += 3;
+    }
+  }
+  return score;
+}
+function setServerLocation(url) {
+  serverLocation = url;
+}
+function parseLocation(url) {
+  try {
+    const u = new URL(url, "http://localhost");
+    return { pathname: u.pathname, search: u.search, hash: u.hash };
+  } catch {
+    return { pathname: "/", search: "", hash: "" };
+  }
+}
+function deepFreeze(obj) {
+  if (obj && typeof obj === "object" && !Object.isFrozen(obj)) {
+    Object.freeze(obj);
+    for (const key of Object.keys(obj)) {
+      const value = obj[key];
+      if (value && typeof value === "object") deepFreeze(value);
+    }
+  }
+  return obj;
+}
+function makeQuery(search) {
+  const usp = new URLSearchParams(search || "");
+  const mapping = /* @__PURE__ */ new Map();
+  for (const [k, v] of usp.entries()) {
+    const existing = mapping.get(k);
+    if (existing) existing.push(v);
+    else mapping.set(k, [v]);
+  }
+  const obj = {
+    get(key) {
+      const arr = mapping.get(key);
+      return arr ? arr[0] : null;
+    },
+    getAll(key) {
+      const arr = mapping.get(key);
+      return arr ? [...arr] : [];
+    },
+    has(key) {
+      return mapping.has(key);
+    },
+    toJSON() {
+      const out = {};
+      for (const [k, arr] of mapping.entries()) {
+        out[k] = arr.length > 1 ? [...arr] : arr[0];
+      }
+      return out;
+    }
+  };
+  return deepFreeze(obj);
+}
+function computeMatches(pathname) {
+  const routesList = getRoutes();
+  const matches = [];
+  function getSpecificity2(path) {
+    const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+    if (normalized === "/*") return 0;
+    const segments = normalized.split("/").filter(Boolean);
+    let score = 0;
+    for (const segment of segments) {
+      if (segment.startsWith("{") && segment.endsWith("}")) score += 2;
+      else if (segment === "*") score += 1;
+      else score += 3;
+    }
+    return score;
+  }
+  for (const r of routesList) {
+    const result = match(pathname, r.path);
+    if (result.matched) {
+      matches.push({
+        pattern: r.path,
+        params: result.params,
+        name: r.name,
+        namespace: r.namespace,
+        specificity: getSpecificity2(r.path)
+      });
+    }
+  }
+  matches.sort((a, b) => b.specificity - a.specificity);
+  return matches.map((m) => ({
+    path: m.pattern,
+    params: deepFreeze({ ...m.params }),
+    name: m.name,
+    namespace: m.namespace
+  }));
+}
+function lockRouteRegistration() {
+  registrationLocked = true;
+}
+function _lockRouteRegistrationForTests() {
+  registrationLocked = true;
+}
+function _unlockRouteRegistrationForTests() {
+  registrationLocked = false;
+}
+function route(path, handler, namespace) {
+  if (getExecutionModel() === "islands") {
+    throw new Error(
+      "Routes are not supported with islands. Use createSPA (client) or createSSR (server) instead."
+    );
+  }
+  if (typeof path === "undefined") {
+    const instance = getCurrentComponentInstance();
+    if (!instance) {
+      throw new Error(
+        "route() can only be called during component render execution. Call route() from inside your component function."
+      );
+    }
+    let pathname = "/";
+    let search = "";
+    let hash = "";
+    if (typeof window !== "undefined" && window.location) {
+      pathname = window.location.pathname || "/";
+      search = window.location.search || "";
+      hash = window.location.hash || "";
+    } else if (serverLocation) {
+      const parsed = parseLocation(serverLocation);
+      pathname = parsed.pathname;
+      search = parsed.search;
+      hash = parsed.hash;
+    }
+    const params = deepFreeze({
+      ...instance.props || {}
+    });
+    const query = makeQuery(search);
+    const matches = computeMatches(pathname);
+    const snapshot = Object.freeze({
+      path: pathname,
+      params,
+      query,
+      hash: hash || null,
+      matches: Object.freeze(matches)
+    });
+    return snapshot;
+  }
+  const currentInst = getCurrentComponentInstance();
+  if (currentInst && currentInst.ssr) {
+    throw new Error(
+      "route() cannot be called during SSR rendering. Register routes at module load time instead."
+    );
+  }
+  if (registrationLocked) {
+    throw new Error(
+      "Route registration is locked after app startup. Register routes at module load time before calling createSPA or createSSR."
+    );
+  }
+  if (typeof handler !== "function") {
+    throw new Error(
+      "route(path, handler) requires a function handler that returns a VNode (e.g. () => <Page />). Passing JSX elements or VNodes directly is not supported."
+    );
+  }
+  const routeObj = { path, handler, namespace };
+  routes.push(routeObj);
+  setHasRoutes(true);
+  const depth = getDepth(path);
+  let depthRoutes = routesByDepth.get(depth);
+  if (!depthRoutes) {
+    depthRoutes = [];
+    routesByDepth.set(depth, depthRoutes);
+  }
+  depthRoutes.push(routeObj);
+  if (namespace) {
+    namespaces.add(namespace);
+  }
+}
+function getRoutes() {
+  return [...routes];
+}
+function getNamespaceRoutes(namespace) {
+  return routes.filter((r) => r.namespace === namespace);
+}
+function unloadNamespace(namespace) {
+  const before = routes.length;
+  for (let i = routes.length - 1; i >= 0; i--) {
+    if (routes[i].namespace === namespace) {
+      const removed = routes[i];
+      routes.splice(i, 1);
+      const depth = getDepth(removed.path);
+      const depthRoutes = routesByDepth.get(depth);
+      if (depthRoutes) {
+        const idx = depthRoutes.indexOf(removed);
+        if (idx >= 0) {
+          depthRoutes.splice(idx, 1);
+        }
+      }
+    }
+  }
+  namespaces.delete(namespace);
+  return before - routes.length;
+}
+function clearRoutes() {
+  routes.length = 0;
+  namespaces.clear();
+  routesByDepth.clear();
+  registrationLocked = false;
+  setHasRoutes(false);
+}
+function normalizeHandler(handler) {
+  if (handler == null) return void 0;
+  if (typeof handler === "function") {
+    return (params, ctx) => {
+      try {
+        return handler(params, ctx);
+      } catch {
+        return handler(params);
+      }
+    };
+  }
+  return void 0;
+}
+function registerRoute(path, handler, ...children) {
+  const isRelative = !path.startsWith("/");
+  const descriptor = {
+    path,
+    handler,
+    children: children.filter(Boolean),
+    _isDescriptor: true
+  };
+  if (!isRelative) {
+    const normalized = normalizeHandler(handler);
+    if (handler != null && !normalized) {
+      throw new Error(
+        "registerRoute(path, handler) requires a function handler. Passing JSX elements or VNodes directly is not supported."
+      );
+    }
+    if (normalized) route(path, normalized);
+    for (const child of descriptor.children || []) {
+      const base = path === "/" ? "" : path.replace(/\/$/, "");
+      const childPath = `${base}/${child.path.replace(/^\//, "")}`.replace(
+        /\/\//g,
+        "/"
+      );
+      if (child.handler) {
+        const childNormalized = normalizeHandler(child.handler);
+        if (!childNormalized) {
+          throw new Error(
+            "registerRoute child handler must be a function. Passing JSX elements directly is not supported."
+          );
+        }
+        if (childNormalized) route(childPath, childNormalized);
+      }
+      if (child.children && child.children.length) {
+        registerRoute(
+          childPath,
+          null,
+          ...child.children
+        );
+      }
+    }
+    return descriptor;
+  }
+  return descriptor;
+}
+function getLoadedNamespaces() {
+  return Array.from(namespaces);
+}
+function resolveRoute(pathname) {
+  const normalized = pathname.endsWith("/") && pathname !== "/" ? pathname.slice(0, -1) : pathname;
+  const depth = normalized === "/" ? 0 : normalized.split("/").filter(Boolean).length;
+  const candidates = [];
+  const depthRoutes = routesByDepth.get(depth);
+  if (depthRoutes) {
+    for (const r of depthRoutes) {
+      const result = match(pathname, r.path);
+      if (result.matched) {
+        candidates.push({
+          route: r,
+          specificity: getSpecificity(r.path),
+          params: result.params
+        });
+      }
+    }
+  }
+  for (const r of routes) {
+    if (depthRoutes?.includes(r)) continue;
+    const result = match(pathname, r.path);
+    if (result.matched) {
+      candidates.push({
+        route: r,
+        specificity: getSpecificity(r.path),
+        params: result.params
+      });
+    }
+  }
+  candidates.sort((a, b) => b.specificity - a.specificity);
+  if (candidates.length > 0) {
+    const best = candidates[0];
+    return { handler: best.route.handler, params: best.params };
+  }
+  return null;
+}
+var routes, namespaces, HAS_ROUTES_KEY, routesByDepth, serverLocation, registrationLocked;
+var init_route = __esm({
+  "src/router/route.ts"() {
+    init_match();
+    init_component();
+    init_execution_model();
+    routes = [];
+    namespaces = /* @__PURE__ */ new Set();
+    HAS_ROUTES_KEY = /* @__PURE__ */ Symbol.for("__ASKR_HAS_ROUTES__");
+    setHasRoutes(false);
+    routesByDepth = /* @__PURE__ */ new Map();
+    serverLocation = null;
+    registrationLocked = false;
+  }
+});
+
+// src/router/navigate.ts
+function registerAppInstance(instance, _path) {
+  currentInstance2 = instance;
+  if (process.env.NODE_ENV === "production") {
+    lockRouteRegistration();
+  }
+}
+function handlePopState(_event) {
+  const path = window.location.pathname;
+  if (!currentInstance2) {
+    return;
+  }
+  const resolved = resolveRoute(path);
+  if (resolved) {
+    cleanupComponent(currentInstance2);
+    currentInstance2.fn = resolved.handler;
+    currentInstance2.props = resolved.params;
+    currentInstance2.stateValues = [];
+    currentInstance2.expectedStateIndices = [];
+    currentInstance2.firstRenderComplete = false;
+    currentInstance2.stateIndexCheck = -1;
+    currentInstance2.evaluationGeneration++;
+    currentInstance2.notifyUpdate = null;
+    currentInstance2.abortController = new AbortController();
+    mountComponent(currentInstance2);
+  }
+}
+function initializeNavigation() {
+  if (typeof window !== "undefined") {
+    window.addEventListener("popstate", handlePopState);
+  }
+}
+var currentInstance2;
+var init_navigate = __esm({
+  "src/router/navigate.ts"() {
+    init_route();
+    init_component();
+    currentInstance2 = null;
+  }
+});
+
+// src/jsx/index.ts
+var init_jsx2 = __esm({
+  "src/jsx/index.ts"() {
+    init_types2();
+  }
+});
+
+// src/foundations/portal.tsx
+function definePortal() {
+  if (typeof createPortalSlot !== "function") {
+    let HostFallback2 = function() {
+      if (owner && owner.mounted === false) {
+        owner = null;
+        pending = void 0;
+      }
+      const inst = getCurrentComponentInstance();
+      if (!owner && inst) owner = inst;
+      if (process.env.NODE_ENV !== "production") {
+        const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
+        ns.__PORTAL_READS = (ns.__PORTAL_READS || 0) + 1;
+      }
+      if (process.env.NODE_ENV !== "production") {
+        if (inst && owner && inst !== owner && inst.mounted === true) {
+          logger.warn(
+            "[Portal] multiple mounted hosts detected; first mounted host is owner"
+          );
+        }
+      }
+      return inst && owner && inst === owner ? pending : void 0;
+    };
+    let owner = null;
+    let pending;
+    HostFallback2.render = function RenderFallback(props) {
+      if (!owner || owner.mounted !== true) return null;
+      if (process.env.NODE_ENV !== "production") {
+        const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
+        ns.__PORTAL_WRITES = (ns.__PORTAL_WRITES || 0) + 1;
+      }
+      pending = props.children;
+      if (owner.notifyUpdate) owner.notifyUpdate();
+      return null;
+    };
+    return HostFallback2;
+  }
+  const slot = createPortalSlot();
+  function PortalHost() {
+    return slot.read();
+  }
+  PortalHost.render = function PortalRender(props) {
+    if (process.env.NODE_ENV !== "production") {
+      const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
+      ns.__PORTAL_WRITES = (ns.__PORTAL_WRITES || 0) + 1;
+    }
+    slot.write(props.children);
+    return null;
+  };
+  return PortalHost;
+}
+function ensureDefaultPortal() {
+  if (!_defaultPortal) {
+    if (typeof createPortalSlot === "function") {
+      _defaultPortal = definePortal();
+      _defaultPortalIsFallback = false;
+    } else {
+      _defaultPortal = definePortal();
+      _defaultPortalIsFallback = true;
+    }
+    return _defaultPortal;
+  }
+  if (_defaultPortalIsFallback && typeof createPortalSlot === "function") {
+    const real = definePortal();
+    _defaultPortal = real;
+    _defaultPortalIsFallback = false;
+  }
+  if (!_defaultPortalIsFallback && typeof createPortalSlot !== "function") {
+    const fallback = definePortal();
+    _defaultPortal = fallback;
+    _defaultPortalIsFallback = true;
+  }
+  return _defaultPortal;
+}
+var _defaultPortal, _defaultPortalIsFallback, DefaultPortal;
+var init_portal = __esm({
+  "src/foundations/portal.tsx"() {
+    init_component();
+    init_logger();
+    _defaultPortalIsFallback = false;
+    DefaultPortal = (() => {
+      function Host() {
+        const v = ensureDefaultPortal()();
+        return v === void 0 ? null : v;
+      }
+      Host.render = function Render(props) {
+        ensureDefaultPortal().render(props);
+        return null;
+      };
+      return Host;
+    })();
+  }
+});
 
 // src/boot/index.ts
-var HAS_ROUTES_KEY = /* @__PURE__ */ Symbol.for("__ASKR_HAS_ROUTES__");
+init_component();
+init_scheduler();
+init_logger();
+init_navigate();
+init_execution_model();
+init_jsx2();
+init_portal();
+init_renderer();
+var HAS_ROUTES_KEY2 = /* @__PURE__ */ Symbol.for("__ASKR_HAS_ROUTES__");
 var componentIdCounter = 0;
 var instancesByRoot = /* @__PURE__ */ new WeakMap();
 var CLEANUP_SYMBOL = /* @__PURE__ */ Symbol.for("__tempoCleanup__");
@@ -183,7 +3736,7 @@ function createIsland(config) {
   }
   try {
     const g = globalThis;
-    if (g[HAS_ROUTES_KEY]) {
+    if (g[HAS_ROUTES_KEY2]) {
       throw new Error(
         "Routes are not supported with islands. Use createSPA (client) or createSSR (server) instead."
       );
@@ -206,14 +3759,14 @@ async function createSPA(config) {
   }
   const rootElement = typeof config.root === "string" ? document.getElementById(config.root) : config.root;
   if (!rootElement) throw new Error(`Root element not found: ${config.root}`);
-  const { clearRoutes, route, lockRouteRegistration, resolveRoute } = await import("./route-BCND6MPK.js");
-  clearRoutes();
+  const { clearRoutes: clearRoutes2, route: route2, lockRouteRegistration: lockRouteRegistration2, resolveRoute: resolveRoute2 } = await Promise.resolve().then(() => (init_route(), route_exports));
+  clearRoutes2();
   for (const r of config.routes) {
-    route(r.path, r.handler, r.namespace);
+    route2(r.path, r.handler, r.namespace);
   }
-  if (process.env.NODE_ENV === "production") lockRouteRegistration();
+  if (process.env.NODE_ENV === "production") lockRouteRegistration2();
   const path = typeof window !== "undefined" ? window.location.pathname : "/";
-  const resolved = resolveRoute(path);
+  const resolved = resolveRoute2(path);
   if (!resolved) {
     if (process.env.NODE_ENV !== "production") {
       logger.warn(
@@ -225,7 +3778,7 @@ async function createSPA(config) {
     });
     const instance2 = instancesByRoot.get(rootElement);
     if (!instance2) throw new Error("Internal error: app instance missing");
-    registerAppInstance(instance2, path);
+    registerAppInstance(instance2);
     initializeNavigation();
     return;
   }
@@ -234,11 +3787,128 @@ async function createSPA(config) {
   });
   const instance = instancesByRoot.get(rootElement);
   if (!instance) throw new Error("Internal error: app instance missing");
-  registerAppInstance(instance, path);
+  registerAppInstance(instance);
   initializeNavigation();
 }
 
+// src/runtime/state.ts
+init_scheduler();
+init_component();
+init_invariant();
+init_fastlane();
+function state(initialValue) {
+  const instance = getCurrentInstance();
+  if (!instance) {
+    throw new Error(
+      "state() can only be called during component render execution. Move state() calls to the top level of your component function."
+    );
+  }
+  const index = getNextStateIndex();
+  const stateValues = instance.stateValues;
+  if (index < instance.stateIndexCheck) {
+    throw new Error(
+      `State index violation: state() call at index ${index}, but previously saw index ${instance.stateIndexCheck}. This happens when state() is called conditionally (inside if/for/etc). Move all state() calls to the top level of your component function, before any conditionals.`
+    );
+  }
+  invariant(
+    index >= instance.stateIndexCheck,
+    "[State] State indices must increase monotonically"
+  );
+  instance.stateIndexCheck = index;
+  if (instance.firstRenderComplete) {
+    if (!instance.expectedStateIndices.includes(index)) {
+      throw new Error(
+        `Hook order violation: state() called at index ${index}, but this index was not in the first render's sequence [${instance.expectedStateIndices.join(", ")}]. This usually means state() is inside a conditional or loop. Move all state() calls to the top level of your component function.`
+      );
+    }
+  } else {
+    instance.expectedStateIndices.push(index);
+  }
+  if (stateValues[index]) {
+    const existing = stateValues[index];
+    if (existing._owner !== instance) {
+      throw new Error(
+        `State ownership violation: state() called at index ${index} is owned by a different component instance. State ownership is positional and immutable.`
+      );
+    }
+    return existing;
+  }
+  const cell = createStateCell(initialValue, instance);
+  stateValues[index] = cell;
+  return cell;
+}
+function createStateCell(initialValue, instance) {
+  let value = initialValue;
+  const readers = /* @__PURE__ */ new Map();
+  function read() {
+    read._hasBeenRead = true;
+    const inst = getCurrentInstance();
+    if (inst && inst._currentRenderToken !== void 0) {
+      if (!inst._pendingReadStates) inst._pendingReadStates = /* @__PURE__ */ new Set();
+      inst._pendingReadStates.add(read);
+    }
+    return value;
+  }
+  read._readers = readers;
+  read._owner = instance;
+  read.set = (newValueOrUpdater) => {
+    const currentInst = getCurrentInstance();
+    if (currentInst !== null) {
+      throw new Error(
+        `[Askr] state.set() cannot be called during component render. State mutations during render break the actor model and cause infinite loops. Move state updates to event handlers or use conditional rendering instead.`
+      );
+    }
+    let newValue;
+    if (typeof newValueOrUpdater === "function") {
+      const updater = newValueOrUpdater;
+      newValue = updater(value);
+    } else {
+      newValue = newValueOrUpdater;
+    }
+    if (Object.is(value, newValue)) return;
+    if (isBulkCommitActive2()) {
+      value = newValue;
+      return;
+    }
+    value = newValue;
+    const readersMap = read._readers;
+    if (readersMap) {
+      for (const [subInst, token] of readersMap) {
+        if (subInst.lastRenderToken !== token) continue;
+        if (!subInst.hasPendingUpdate) {
+          subInst.hasPendingUpdate = true;
+          const subTask = subInst._pendingFlushTask;
+          if (subTask) globalScheduler.enqueue(subTask);
+          else
+            globalScheduler.enqueue(() => {
+              subInst.hasPendingUpdate = false;
+              subInst.notifyUpdate?.();
+            });
+        }
+      }
+    }
+    const readersMapForOwner = readersMap;
+    const ownerRecordedToken = readersMapForOwner?.get(instance);
+    const ownerShouldEnqueue = (
+      // Normal case: owner read this state in last committed render
+      ownerRecordedToken !== void 0 && instance.lastRenderToken === ownerRecordedToken
+    );
+    if (ownerShouldEnqueue && !instance.hasPendingUpdate) {
+      instance.hasPendingUpdate = true;
+      const task = instance._pendingFlushTask;
+      if (task) globalScheduler.enqueue(task);
+      else
+        globalScheduler.enqueue(() => {
+          instance.hasPendingUpdate = false;
+          instance.notifyUpdate?.();
+        });
+    }
+  };
+  return read;
+}
+
 // src/runtime/derive.ts
+init_component();
 var deriveCaches = /* @__PURE__ */ new WeakMap();
 function getDeriveCache(instance) {
   let cache = deriveCaches.get(instance);
@@ -280,10 +3950,7 @@ function derive(source, map) {
   cache.set(value, result);
   return result;
 }
-export {
-  createIsland,
-  createSPA,
-  derive,
-  state
-};
+
+export { createIsland, createSPA, derive, state };
+//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map