@askrjs/askr 0.0.1

package/dist/index.cjs

@@ -0,0 +1,4733 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/dev/invariant.ts
+function invariant(condition, message, context) {
+  if (!condition) {
+    const contextStr = context ? "\n" + JSON.stringify(context, null, 2) : "";
+    throw new Error(`[Askr Invariant] ${message}${contextStr}`);
+  }
+}
+function assertSchedulingPrecondition(condition, violationMessage) {
+  invariant(condition, `[Scheduler Precondition] ${violationMessage}`);
+}
+var init_invariant = __esm({
+  "src/dev/invariant.ts"() {
+    "use strict";
+  }
+});
+
+// src/dev/logger.ts
+function callConsole(method, args) {
+  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"() {
+    "use strict";
+    logger = {
+      debug: (...args) => {
+        if (process.env.NODE_ENV === "production") return;
+        callConsole("debug", args);
+      },
+      info: (...args) => {
+        if (process.env.NODE_ENV === "production") return;
+        callConsole("info", args);
+      },
+      warn: (...args) => {
+        if (process.env.NODE_ENV === "production") return;
+        callConsole("warn", args);
+      },
+      error: (...args) => {
+        callConsole("error", args);
+      }
+    };
+  }
+});
+
+// src/runtime/scheduler.ts
+function isBulkCommitActive() {
+  try {
+    const fb = globalThis.__ASKR_FASTLANE;
+    return typeof fb?.isBulkCommitActive === "function" ? !!fb.isBulkCommitActive() : false;
+  } catch (e) {
+    void e;
+    return false;
+  }
+}
+function isSchedulerExecuting() {
+  return globalScheduler.isExecuting();
+}
+function scheduleEventHandler(handler) {
+  return (event) => {
+    globalScheduler.setInHandler(true);
+    try {
+      handler.call(null, event);
+    } catch (error) {
+      logger.error("[Askr] Event handler error:", error);
+    } finally {
+      globalScheduler.setInHandler(false);
+      const state2 = globalScheduler.getState();
+      if ((state2.queueLength ?? 0) > 0 && !state2.running) {
+        queueMicrotask(() => {
+          try {
+            if (!globalScheduler.isExecuting()) globalScheduler.flush();
+          } catch (err) {
+            setTimeout(() => {
+              throw err;
+            });
+          }
+        });
+      }
+    }
+  };
+}
+var MAX_FLUSH_DEPTH, Scheduler, globalScheduler;
+var init_scheduler = __esm({
+  "src/runtime/scheduler.ts"() {
+    "use strict";
+    init_invariant();
+    init_logger();
+    MAX_FLUSH_DEPTH = 50;
+    Scheduler = class {
+      constructor() {
+        this.q = [];
+        this.head = 0;
+        this.running = false;
+        this.inHandler = false;
+        this.depth = 0;
+        this.executionDepth = 0;
+        // for compat with existing diagnostics
+        // Monotonic flush version increments at end of each flush
+        this.flushVersion = 0;
+        // Best-effort microtask kick scheduling
+        this.kickScheduled = false;
+        // Escape hatch flag for runWithSyncProgress
+        this.allowSyncProgress = false;
+        // Waiters waiting for flushVersion >= target
+        this.waiters = [];
+        // Keep a lightweight taskCount for compatibility/diagnostics
+        this.taskCount = 0;
+      }
+      enqueue(task) {
+        assertSchedulingPrecondition(
+          typeof task === "function",
+          "enqueue() requires a function"
+        );
+        if (isBulkCommitActive() && !this.allowSyncProgress) {
+          if (process.env.NODE_ENV !== "production") {
+            throw new Error(
+              "[Scheduler] enqueue() during bulk commit (not allowed)"
+            );
+          }
+          return;
+        }
+        this.q.push(task);
+        this.taskCount++;
+        if (!this.running && !this.kickScheduled && !this.inHandler && !isBulkCommitActive()) {
+          this.kickScheduled = true;
+          queueMicrotask(() => {
+            this.kickScheduled = false;
+            if (this.running) return;
+            if (isBulkCommitActive()) return;
+            try {
+              this.flush();
+            } catch (err) {
+              setTimeout(() => {
+                throw err;
+              });
+            }
+          });
+        }
+      }
+      flush() {
+        invariant(
+          !this.running,
+          "[Scheduler] flush() called while already running"
+        );
+        if (process.env.NODE_ENV !== "production") {
+          if (isBulkCommitActive() && !this.allowSyncProgress) {
+            throw new Error(
+              "[Scheduler] flush() started during bulk commit (not allowed)"
+            );
+          }
+        }
+        this.running = true;
+        this.depth = 0;
+        let fatal = null;
+        try {
+          while (this.head < this.q.length) {
+            this.depth++;
+            if (process.env.NODE_ENV !== "production" && this.depth > MAX_FLUSH_DEPTH) {
+              throw new Error(
+                `[Scheduler] exceeded MAX_FLUSH_DEPTH (${MAX_FLUSH_DEPTH}). Likely infinite update loop.`
+              );
+            }
+            const task = this.q[this.head++];
+            try {
+              this.executionDepth++;
+              task();
+              this.executionDepth--;
+            } catch (err) {
+              if (this.executionDepth > 0) this.executionDepth = 0;
+              fatal = err;
+              break;
+            }
+            if (this.taskCount > 0) this.taskCount--;
+          }
+        } finally {
+          this.running = false;
+          this.depth = 0;
+          this.executionDepth = 0;
+          if (this.head >= this.q.length) {
+            this.q.length = 0;
+            this.head = 0;
+          } else if (this.head > 0) {
+            const remaining = this.q.length - this.head;
+            if (this.head > 1024 || this.head > remaining) {
+              this.q = this.q.slice(this.head);
+            } else {
+              for (let i = 0; i < remaining; i++) {
+                this.q[i] = this.q[this.head + i];
+              }
+              this.q.length = remaining;
+            }
+            this.head = 0;
+          }
+          this.flushVersion++;
+          this.resolveWaiters();
+        }
+        if (fatal) throw fatal;
+      }
+      runWithSyncProgress(fn) {
+        const prev = this.allowSyncProgress;
+        this.allowSyncProgress = true;
+        const g = globalThis;
+        const origQueueMicrotask = g.queueMicrotask;
+        const origSetTimeout = g.setTimeout;
+        if (process.env.NODE_ENV !== "production") {
+          g.queueMicrotask = () => {
+            throw new Error(
+              "[Scheduler] queueMicrotask not allowed during runWithSyncProgress"
+            );
+          };
+          g.setTimeout = () => {
+            throw new Error(
+              "[Scheduler] setTimeout not allowed during runWithSyncProgress"
+            );
+          };
+        }
+        const startVersion = this.flushVersion;
+        try {
+          const res = fn();
+          if (!this.running && this.q.length - this.head > 0) {
+            this.flush();
+          }
+          if (process.env.NODE_ENV !== "production") {
+            if (this.q.length - this.head > 0) {
+              throw new Error(
+                "[Scheduler] tasks remain after runWithSyncProgress flush"
+              );
+            }
+          }
+          return res;
+        } finally {
+          if (process.env.NODE_ENV !== "production") {
+            g.queueMicrotask = origQueueMicrotask;
+            g.setTimeout = origSetTimeout;
+          }
+          try {
+            if (this.flushVersion === startVersion) {
+              this.flushVersion++;
+              this.resolveWaiters();
+            }
+          } catch (e) {
+            void e;
+          }
+          this.allowSyncProgress = prev;
+        }
+      }
+      waitForFlush(targetVersion, timeoutMs = 2e3) {
+        const target = typeof targetVersion === "number" ? targetVersion : this.flushVersion + 1;
+        if (this.flushVersion >= target) return Promise.resolve();
+        return new Promise((resolve, reject) => {
+          const timer = setTimeout(() => {
+            const diag = {
+              flushVersion: this.flushVersion,
+              queueLen: this.q.length - this.head,
+              running: this.running,
+              inHandler: this.inHandler,
+              bulk: isBulkCommitActive(),
+              globals: {
+                __ASKR_LAST_FASTPATH_STATS: globalThis.__ASKR_LAST_FASTPATH_STATS,
+                __ASKR_LAST_BULK_TEXT_FASTPATH_STATS: globalThis.__ASKR_LAST_BULK_TEXT_FASTPATH_STATS,
+                __ASKR_FASTPATH_COUNTERS: globalThis.__ASKR_FASTPATH_COUNTERS
+              }
+            };
+            reject(
+              new Error(
+                `waitForFlush timeout ${timeoutMs}ms: ${JSON.stringify(diag)}`
+              )
+            );
+          }, timeoutMs);
+          this.waiters.push({ target, resolve, reject, timer });
+        });
+      }
+      getState() {
+        return {
+          queueLength: this.q.length - this.head,
+          running: this.running,
+          depth: this.depth,
+          executionDepth: this.executionDepth,
+          taskCount: this.taskCount,
+          flushVersion: this.flushVersion,
+          // New fields for optional inspection
+          inHandler: this.inHandler,
+          allowSyncProgress: this.allowSyncProgress
+        };
+      }
+      setInHandler(v) {
+        this.inHandler = v;
+      }
+      isInHandler() {
+        return this.inHandler;
+      }
+      isExecuting() {
+        return this.running || this.executionDepth > 0;
+      }
+      // Clear pending synchronous tasks (used by fastlane enter/exit)
+      clearPendingSyncTasks() {
+        const remaining = this.q.length - this.head;
+        if (remaining <= 0) return 0;
+        if (this.running) {
+          this.q.length = this.head;
+          this.taskCount = Math.max(0, this.taskCount - remaining);
+          queueMicrotask(() => {
+            try {
+              this.flushVersion++;
+              this.resolveWaiters();
+            } catch (e) {
+              void e;
+            }
+          });
+          return remaining;
+        }
+        this.q.length = 0;
+        this.head = 0;
+        this.taskCount = Math.max(0, this.taskCount - remaining);
+        this.flushVersion++;
+        this.resolveWaiters();
+        return remaining;
+      }
+      resolveWaiters() {
+        if (this.waiters.length === 0) return;
+        const ready = [];
+        const remaining = [];
+        for (const w of this.waiters) {
+          if (this.flushVersion >= w.target) {
+            if (w.timer) clearTimeout(w.timer);
+            ready.push(w.resolve);
+          } else {
+            remaining.push(w);
+          }
+        }
+        this.waiters = remaining;
+        for (const r of ready) r();
+      }
+    };
+    globalScheduler = new Scheduler();
+  }
+});
+
+// src/runtime/fastlane.ts
+function enterBulkCommit() {
+  _bulkCommitActive = true;
+  _appliedParents = /* @__PURE__ */ new WeakSet();
+  try {
+    const cleared = globalScheduler.clearPendingSyncTasks?.() ?? 0;
+    if (process.env.NODE_ENV !== "production") {
+      const _g = globalThis;
+      _g.__ASKR_FASTLANE_CLEARED_TASKS = cleared;
+    }
+  } catch (err) {
+    if (process.env.NODE_ENV !== "production") throw err;
+  }
+}
+function exitBulkCommit() {
+  _bulkCommitActive = false;
+  _appliedParents = null;
+}
+function isBulkCommitActive2() {
+  return _bulkCommitActive;
+}
+function markFastPathApplied(parent) {
+  if (!_appliedParents) return;
+  try {
+    _appliedParents.add(parent);
+  } catch (e) {
+    void e;
+  }
+}
+function isFastPathApplied(parent) {
+  return !!(_appliedParents && _appliedParents.has(parent));
+}
+function classifyUpdate(instance, result) {
+  if (!result || typeof result !== "object" || !("type" in result))
+    return { useFastPath: false, reason: "not-vnode" };
+  const vnode = result;
+  if (vnode == null || typeof vnode.type !== "string")
+    return { useFastPath: false, reason: "not-intrinsic" };
+  const parent = instance.target;
+  if (!parent) return { useFastPath: false, reason: "no-root" };
+  const firstChild = parent.children[0];
+  if (!firstChild) return { useFastPath: false, reason: "no-first-child" };
+  if (firstChild.tagName.toLowerCase() !== String(vnode.type).toLowerCase())
+    return { useFastPath: false, reason: "root-tag-mismatch" };
+  const children = vnode.children || vnode.props?.children;
+  if (!Array.isArray(children))
+    return { useFastPath: false, reason: "no-children-array" };
+  for (let i = 0; i < children.length; i++) {
+    const c = children[i];
+    if (typeof c === "object" && c !== null && "type" in c && typeof c.type === "function") {
+      return { useFastPath: false, reason: "component-child-present" };
+    }
+  }
+  if (instance.mountOperations.length > 0)
+    return { useFastPath: false, reason: "pending-mounts" };
+  const oldKeyMap = getKeyMapForElement(firstChild);
+  const decision = isKeyedReorderFastPathEligible(
+    firstChild,
+    children,
+    oldKeyMap
+  );
+  if (!decision.useFastPath || decision.totalKeyed < 128)
+    return { ...decision, useFastPath: false, reason: "renderer-declined" };
+  return { ...decision, useFastPath: true };
+}
+function commitReorderOnly(instance, result) {
+  const evaluate2 = globalThis.__ASKR_RENDERER?.evaluate;
+  if (typeof evaluate2 !== "function") {
+    logger.warn(
+      "[Tempo][FASTPATH][DEV] renderer.evaluate not available; declining fast-lane"
+    );
+    return false;
+  }
+  const schedBefore = process.env.NODE_ENV !== "production" ? globalScheduler.getState() : null;
+  enterBulkCommit();
+  try {
+    globalScheduler.runWithSyncProgress(() => {
+      evaluate2(result, instance.target);
+      try {
+        const comp = (init_component(), __toCommonJS(component_exports));
+        if (typeof comp?.finalizeReadSubscriptions === "function") {
+          try {
+            comp.finalizeReadSubscriptions(instance);
+          } catch (e) {
+            if (process.env.NODE_ENV !== "production") throw e;
+          }
+        }
+      } catch (e) {
+        void e;
+      }
+    });
+    try {
+      const clearedAfter = globalScheduler.clearPendingSyncTasks?.() ?? 0;
+      if (process.env.NODE_ENV !== "production") {
+        const _g = globalThis;
+        _g.__ASKR_FASTLANE_CLEARED_AFTER = clearedAfter;
+      }
+    } catch (err) {
+      if (process.env.NODE_ENV !== "production") throw err;
+    }
+    if (process.env.NODE_ENV !== "production") {
+      const _g = globalThis;
+      const commitCount = _g.__ASKR_LAST_FASTPATH_COMMIT_COUNT ?? 0;
+      const invariants = {
+        commitCount,
+        mountOps: instance.mountOperations.length,
+        cleanupFns: instance.cleanupFns.length
+      };
+      _g.__ASKR_LAST_FASTLANE_INVARIANTS = invariants;
+      if (commitCount !== 1) {
+        throw new Error(
+          "Fast-lane invariant violated: expected exactly one DOM commit during reorder-only commit"
+        );
+      }
+      if (invariants.mountOps > 0) {
+        throw new Error(
+          "Fast-lane invariant violated: mount operations were registered during bulk commit"
+        );
+      }
+      if (invariants.cleanupFns > 0) {
+        throw new Error(
+          "Fast-lane invariant violated: cleanup functions were added during bulk commit"
+        );
+      }
+      const schedAfter = globalScheduler.getState();
+      if (schedBefore && schedAfter && // Only fail if outstanding tasks increased — consuming existing tasks is allowed
+      schedAfter.taskCount > schedBefore.taskCount) {
+        try {
+          console.error(
+            "[FASTLANE] schedBefore, schedAfter",
+            schedBefore,
+            schedAfter
+          );
+          console.error(
+            "[FASTLANE] enqueue logs",
+            globalThis.__ASKR_ENQUEUE_LOGS
+          );
+        } catch (e) {
+          void e;
+        }
+        throw new Error(
+          "Fast-lane invariant violated: scheduler enqueued leftover work during bulk commit"
+        );
+      }
+      let finalState = globalScheduler.getState();
+      const executing = globalScheduler.isExecuting();
+      const outstandingAfter = Math.max(
+        0,
+        finalState.taskCount - (executing ? 1 : 0)
+      );
+      if (outstandingAfter !== 0) {
+        if (process.env.NODE_ENV !== "production") {
+          let attempts = 0;
+          while (attempts < 5) {
+            const cleared = globalScheduler.clearPendingSyncTasks?.() ?? 0;
+            if (cleared === 0) break;
+            attempts++;
+          }
+          finalState = globalScheduler.getState();
+          const outstandingAfter2 = Math.max(
+            0,
+            finalState.taskCount - (globalScheduler.isExecuting() ? 1 : 0)
+          );
+          if (outstandingAfter2 !== 0) {
+            try {
+              const _g2 = globalThis;
+              console.error(
+                "[FASTLANE] Post-commit enqueue logs:",
+                _g2.__ASKR_ENQUEUE_LOGS
+              );
+              console.error(
+                "[FASTLANE] Cleared counts:",
+                _g2.__ASKR_FASTLANE_CLEARED_TASKS,
+                _g2.__ASKR_FASTLANE_CLEARED_AFTER
+              );
+            } catch (err) {
+              void err;
+            }
+            throw new Error(
+              `Fast-lane invariant violated: scheduler has ${finalState.taskCount} pending task(s) after commit`
+            );
+          }
+        } else {
+          globalScheduler.clearPendingSyncTasks?.();
+        }
+      }
+    }
+    return true;
+  } finally {
+    exitBulkCommit();
+    if (process.env.NODE_ENV !== "production") {
+      try {
+        const _g = globalThis;
+        _g.__ASKR_FASTLANE_BULK_FLAG_CHECK = isBulkCommitActive2();
+      } catch (e) {
+        void e;
+      }
+    }
+  }
+  if (process.env.NODE_ENV !== "production") {
+    const _g = globalThis;
+    if (_g.__ASKR_FASTLANE_BULK_FLAG_CHECK) {
+      delete _g.__ASKR_FASTLANE_BULK_FLAG_CHECK;
+      throw new Error(
+        "Fast-lane invariant violated: bulk commit flag still set after commit"
+      );
+    }
+  }
+}
+function tryRuntimeFastLaneSync(instance, result) {
+  const cls = classifyUpdate(instance, result);
+  if (!cls.useFastPath) return false;
+  try {
+    return commitReorderOnly(instance, result);
+  } catch (err) {
+    if (process.env.NODE_ENV !== "production") throw err;
+    return false;
+  }
+}
+var _bulkCommitActive, _appliedParents;
+var init_fastlane = __esm({
+  "src/runtime/fastlane.ts"() {
+    "use strict";
+    init_scheduler();
+    init_logger();
+    init_dom();
+    _bulkCommitActive = false;
+    _appliedParents = null;
+    if (typeof globalThis !== "undefined") {
+      const _g = globalThis;
+      _g.__ASKR_FASTLANE = {
+        isBulkCommitActive: isBulkCommitActive2,
+        enterBulkCommit,
+        exitBulkCommit,
+        tryRuntimeFastLaneSync,
+        markFastPathApplied,
+        isFastPathApplied
+      };
+    }
+  }
+});
+
+// src/jsx/jsx-runtime.ts
+function jsx(type, props, key) {
+  return {
+    type,
+    props: props || {},
+    key
+  };
+}
+function jsxs(type, props, key) {
+  return jsx(type, props, key);
+}
+var Fragment;
+var init_jsx_runtime = __esm({
+  "src/jsx/jsx-runtime.ts"() {
+    "use strict";
+    Fragment = /* @__PURE__ */ Symbol.for("@askrjs/askr.Fragment");
+  }
+});
+
+// src/runtime/context.ts
+function withContext(frame, fn) {
+  const oldFrame = currentContextFrame;
+  currentContextFrame = frame;
+  try {
+    return fn();
+  } finally {
+    currentContextFrame = oldFrame;
+  }
+}
+function withAsyncResourceContext(frame, fn) {
+  const oldFrame = currentAsyncResourceFrame;
+  currentAsyncResourceFrame = frame;
+  try {
+    return fn();
+  } finally {
+    currentAsyncResourceFrame = oldFrame;
+  }
+}
+function defineContext(defaultValue) {
+  const key = /* @__PURE__ */ Symbol("AskrContext");
+  return {
+    key,
+    defaultValue,
+    Scope: (props) => {
+      return {
+        type: ContextScopeComponent,
+        props: { key, value: props.value, children: props.children }
+      };
+    }
+  };
+}
+function readContext(context) {
+  const frame = currentContextFrame || currentAsyncResourceFrame;
+  if (!frame) {
+    throw new Error(
+      "readContext() can only be called during component render or async resource execution. Ensure you are calling this from inside your component or resource function."
+    );
+  }
+  let current2 = frame;
+  while (current2) {
+    const values = current2.values;
+    if (values && values.has(context.key)) {
+      return values.get(context.key);
+    }
+    current2 = current2.parent;
+  }
+  return context.defaultValue;
+}
+function ContextScopeComponent(props) {
+  const key = props["key"];
+  const value = props["value"];
+  const children = props["children"];
+  const instance = getCurrentComponentInstance();
+  const parentFrame = (() => {
+    if (currentContextFrame) return currentContextFrame;
+    if (instance && instance.ownerFrame) return instance.ownerFrame;
+    return null;
+  })();
+  const newFrame = {
+    parent: parentFrame,
+    values: /* @__PURE__ */ new Map([[key, value]])
+  };
+  if (Array.isArray(children)) {
+    return children.map((child) => {
+      if (typeof child === "function") {
+        return {
+          type: ContextFunctionChildInvoker,
+          props: {
+            fn: child,
+            __frame: newFrame,
+            __owner: getCurrentComponentInstance()
+          }
+        };
+      }
+      return markWithFrame(child, newFrame);
+    });
+  } else if (typeof children === "function") {
+    return {
+      type: ContextFunctionChildInvoker,
+      props: {
+        fn: children,
+        __frame: newFrame,
+        __owner: getCurrentComponentInstance()
+      }
+    };
+  } else if (children) {
+    return markWithFrame(children, newFrame);
+  }
+  return null;
+}
+function markWithFrame(node, frame) {
+  if (typeof node === "object" && node !== null) {
+    const obj = node;
+    obj[CONTEXT_FRAME_SYMBOL] = frame;
+    const children = obj.children;
+    if (Array.isArray(children)) {
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        if (child) {
+          children[i] = markWithFrame(child, frame);
+        }
+      }
+    } else if (children) {
+      obj.children = markWithFrame(children, frame);
+    }
+  }
+  return node;
+}
+function ContextFunctionChildInvoker(props) {
+  const { fn, __frame } = props;
+  const res = withContext(__frame, () => fn());
+  if (res) return markWithFrame(res, __frame);
+  return null;
+}
+function getCurrentContextFrame() {
+  return currentContextFrame;
+}
+var CONTEXT_FRAME_SYMBOL, currentContextFrame, currentAsyncResourceFrame;
+var init_context = __esm({
+  "src/runtime/context.ts"() {
+    "use strict";
+    init_component();
+    CONTEXT_FRAME_SYMBOL = /* @__PURE__ */ Symbol("__tempoContextFrame__");
+    currentContextFrame = null;
+    currentAsyncResourceFrame = null;
+  }
+});
+
+// src/renderer/dom.ts
+function cleanupInstanceIfPresent(node) {
+  if (!node) return;
+  if (!(node instanceof Element)) return;
+  try {
+    const inst = node.__ASKR_INSTANCE;
+    if (inst) {
+      cleanupComponent(inst);
+      try {
+        delete node.__ASKR_INSTANCE;
+      } catch (e) {
+        void e;
+      }
+    }
+  } catch (err) {
+    void err;
+  }
+  try {
+    const descendants = node.querySelectorAll("*");
+    for (const d of Array.from(descendants)) {
+      try {
+        const inst = d.__ASKR_INSTANCE;
+        if (inst) {
+          cleanupComponent(inst);
+          try {
+            delete d.__ASKR_INSTANCE;
+          } catch (e) {
+            void e;
+          }
+        }
+      } catch (err) {
+        void err;
+      }
+    }
+  } catch (err) {
+    void err;
+  }
+}
+function _isDOMElement(node) {
+  return typeof node === "object" && node !== null && "type" in node;
+}
+function getKeyMapForElement(el) {
+  return keyedElements.get(el);
+}
+function removeElementListeners(element) {
+  const map = elementListeners.get(element);
+  if (map) {
+    for (const [eventName, entry] of map) {
+      element.removeEventListener(eventName, entry.handler);
+    }
+    elementListeners.delete(element);
+  }
+}
+function removeAllListeners(root) {
+  if (!root) return;
+  removeElementListeners(root);
+  const children = root.querySelectorAll("*");
+  for (let i = 0; i < children.length; i++) {
+    removeElementListeners(children[i]);
+  }
+}
+function evaluate(node, target, context) {
+  if (!target) return;
+  if (context && domRanges.has(context)) {
+    const range = domRanges.get(context);
+    let current2 = range.start.nextSibling;
+    while (current2 && current2 !== range.end) {
+      const next = current2.nextSibling;
+      current2.remove();
+      current2 = next;
+    }
+    const dom = createDOMNode(node);
+    if (dom) {
+      target.insertBefore(dom, range.end);
+    }
+  } else if (context) {
+    const start = document.createComment("component-start");
+    const end = document.createComment("component-end");
+    target.appendChild(start);
+    target.appendChild(end);
+    domRanges.set(context, { start, end });
+    const dom = createDOMNode(node);
+    if (dom) {
+      target.insertBefore(dom, end);
+    }
+  } else {
+    const vnode = node;
+    const firstChild = target.children[0];
+    if (firstChild && _isDOMElement(vnode) && typeof vnode.type === "string" && firstChild.tagName.toLowerCase() === vnode.type.toLowerCase()) {
+      const vnodeChildren = vnode.children || vnode.props?.children;
+      let isSimpleTextVNode = false;
+      let textContent;
+      if (!Array.isArray(vnodeChildren)) {
+        if (typeof vnodeChildren === "string" || typeof vnodeChildren === "number") {
+          isSimpleTextVNode = true;
+          textContent = String(vnodeChildren);
+        }
+      } else if (vnodeChildren.length === 1) {
+        const child = vnodeChildren[0];
+        if (typeof child === "string" || typeof child === "number") {
+          isSimpleTextVNode = true;
+          textContent = String(child);
+        }
+      }
+      if (isSimpleTextVNode && firstChild.childNodes.length === 1 && firstChild.firstChild?.nodeType === 3) {
+        firstChild.firstChild.data = textContent;
+      } else {
+        if (vnodeChildren) {
+          if (Array.isArray(vnodeChildren)) {
+            const hasKeys = vnodeChildren.some(
+              (child) => typeof child === "object" && child !== null && "key" in child
+            );
+            if (hasKeys) {
+              let oldKeyMap = keyedElements.get(firstChild);
+              if (!oldKeyMap) {
+                oldKeyMap = /* @__PURE__ */ new Map();
+              }
+              try {
+                if (process.env.ASKR_FORCE_BULK_POSREUSE === "1") {
+                  try {
+                    const keyedVnodes = [];
+                    for (let i = 0; i < vnodeChildren.length; i++) {
+                      const c = vnodeChildren[i];
+                      if (_isDOMElement(c) && c.key !== void 0) {
+                        keyedVnodes.push({
+                          key: c.key,
+                          vnode: c
+                        });
+                      }
+                    }
+                    if (keyedVnodes.length > 0 && keyedVnodes.length === vnodeChildren.length) {
+                      logger.warn(
+                        "[Askr][FASTPATH] forced positional bulk keyed reuse (evaluate-level)"
+                      );
+                      const stats = performBulkPositionalKeyedTextUpdate(
+                        firstChild,
+                        keyedVnodes
+                      );
+                      if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+                        try {
+                          const gl = globalThis;
+                          gl.__ASKR_LAST_FASTPATH_STATS = stats;
+                          gl.__ASKR_LAST_FASTPATH_COMMIT_COUNT = 1;
+                          const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
+                          counters.bulkKeyedPositionalForced = (counters.bulkKeyedPositionalForced || 0) + 1;
+                          gl.__ASKR_FASTPATH_COUNTERS = counters;
+                        } catch (e) {
+                          void e;
+                        }
+                      }
+                      try {
+                        const map = /* @__PURE__ */ new Map();
+                        const children = Array.from(firstChild.children);
+                        for (let i = 0; i < children.length; i++) {
+                          const el = children[i];
+                          const k = el.getAttribute("data-key");
+                          if (k !== null) {
+                            map.set(k, el);
+                            const n = Number(k);
+                            if (!Number.isNaN(n)) map.set(n, el);
+                          }
+                        }
+                        keyedElements.set(firstChild, map);
+                      } catch (e) {
+                        void e;
+                      }
+                    } else {
+                      const newKeyMap = reconcileKeyedChildren(
+                        firstChild,
+                        vnodeChildren,
+                        oldKeyMap
+                      );
+                      keyedElements.set(firstChild, newKeyMap);
+                    }
+                  } catch (err) {
+                    logger.warn(
+                      "[Askr][FASTPATH] forced bulk path failed, falling back",
+                      err
+                    );
+                    const newKeyMap = reconcileKeyedChildren(
+                      firstChild,
+                      vnodeChildren,
+                      oldKeyMap
+                    );
+                    keyedElements.set(firstChild, newKeyMap);
+                  }
+                } else {
+                  const newKeyMap = reconcileKeyedChildren(
+                    firstChild,
+                    vnodeChildren,
+                    oldKeyMap
+                  );
+                  keyedElements.set(firstChild, newKeyMap);
+                }
+              } catch (e) {
+                void e;
+                const newKeyMap = reconcileKeyedChildren(
+                  firstChild,
+                  vnodeChildren,
+                  oldKeyMap
+                );
+                keyedElements.set(firstChild, newKeyMap);
+              }
+            } else {
+              if (isBulkTextFastPathEligible(firstChild, vnodeChildren)) {
+                const stats = performBulkTextReplace(firstChild, vnodeChildren);
+                if (process.env.NODE_ENV !== "production") {
+                  try {
+                    const gl = globalThis;
+                    gl.__ASKR_LAST_BULK_TEXT_FASTPATH_STATS = stats;
+                    const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
+                    counters.bulkTextHits = (counters.bulkTextHits || 0) + 1;
+                    gl.__ASKR_FASTPATH_COUNTERS = counters;
+                  } catch (e) {
+                    void e;
+                  }
+                }
+              } else {
+                if (process.env.NODE_ENV !== "production") {
+                  try {
+                    const gl = globalThis;
+                    const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
+                    counters.bulkTextMisses = (counters.bulkTextMisses || 0) + 1;
+                    gl.__ASKR_FASTPATH_COUNTERS = counters;
+                  } catch (e) {
+                    void e;
+                  }
+                }
+                updateUnkeyedChildren(firstChild, vnodeChildren);
+                keyedElements.delete(firstChild);
+              }
+            }
+          } else {
+            firstChild.textContent = "";
+            const dom = createDOMNode(vnodeChildren);
+            if (dom) firstChild.appendChild(dom);
+            keyedElements.delete(firstChild);
+          }
+        } else {
+          firstChild.textContent = "";
+          keyedElements.delete(firstChild);
+        }
+      }
+      updateElementFromVnode(firstChild, vnode, false);
+    } else {
+      target.textContent = "";
+      if (_isDOMElement(vnode) && typeof vnode.type === "string") {
+        const children = vnode.children;
+        if (Array.isArray(children) && children.some(
+          (child) => typeof child === "object" && child !== null && "key" in child
+        )) {
+          const el = document.createElement(vnode.type);
+          target.appendChild(el);
+          const props = vnode.props || {};
+          for (const [key, value] of Object.entries(props)) {
+            if (key === "children" || key === "key") continue;
+            if (value === void 0 || value === null || value === false)
+              continue;
+            if (key.startsWith("on") && key.length > 2) {
+              const eventName = key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();
+              const wrappedHandler = (event) => {
+                globalScheduler.setInHandler(true);
+                try {
+                  value(event);
+                } catch (error) {
+                  logger.error("[Askr] Event handler error:", error);
+                } finally {
+                  globalScheduler.setInHandler(false);
+                }
+              };
+              el.addEventListener(eventName, wrappedHandler);
+              if (!elementListeners.has(el)) {
+                elementListeners.set(el, /* @__PURE__ */ new Map());
+              }
+              elementListeners.get(el).set(eventName, {
+                handler: wrappedHandler,
+                original: value
+              });
+              continue;
+            }
+            if (key === "class" || key === "className") {
+              el.className = String(value);
+            } else if (key === "value" || key === "checked") {
+              el[key] = value;
+            } else {
+              el.setAttribute(key, String(value));
+            }
+          }
+          const newKeyMap = reconcileKeyedChildren(el, children, void 0);
+          keyedElements.set(el, newKeyMap);
+          return;
+          return;
+        }
+      }
+      const dom = createDOMNode(vnode);
+      if (dom) {
+        target.appendChild(dom);
+      }
+    }
+  }
+}
+function isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap) {
+  const keyedVnodes = [];
+  for (let i = 0; i < newChildren.length; i++) {
+    const child = newChildren[i];
+    if (_isDOMElement(child) && child.key !== void 0) {
+      keyedVnodes.push({ key: child.key, vnode: child });
+    }
+  }
+  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 = new Array(keyedVnodes.length).fill(-1);
+    for (let i = 0; i < keyedVnodes.length; i++) {
+      const key = keyedVnodes[i].key;
+      const el = oldKeyMap?.get(key);
+      if (el && el.parentElement === parent) {
+        positions[i] = parentChildren.indexOf(el);
+      }
+    }
+    const tails = [];
+    for (let i = 0; i < positions.length; i++) {
+      const pos = positions[i];
+      if (pos === -1) continue;
+      let lo = 0;
+      let hi = tails.length;
+      while (lo < hi) {
+        const mid = lo + hi >> 1;
+        if (tails[mid] < pos) lo = mid + 1;
+        else hi = mid;
+      }
+      if (lo === tails.length) tails.push(pos);
+      else tails[lo] = pos;
+    }
+    lisLen = tails.length;
+    lisTrigger = lisLen < Math.floor(totalKeyed * 0.5);
+  }
+  let hasPropsPresent = false;
+  for (let i = 0; i < keyedVnodes.length; i++) {
+    const vnode = keyedVnodes[i].vnode;
+    if (!_isDOMElement(vnode)) continue;
+    const props = vnode.props || {};
+    for (const k of Object.keys(props)) {
+      if (k === "children" || k === "key") continue;
+      if (k.startsWith("on") && k.length > 2) continue;
+      if (k.startsWith("data-")) continue;
+      hasPropsPresent = true;
+      break;
+    }
+    if (hasPropsPresent) break;
+  }
+  let hasPropChanges = false;
+  for (let i = 0; i < keyedVnodes.length; i++) {
+    const { key, vnode } = keyedVnodes[i];
+    const el = oldKeyMap?.get(key);
+    if (!el || !_isDOMElement(vnode)) continue;
+    const props = vnode.props || {};
+    for (const k of Object.keys(props)) {
+      if (k === "children" || k === "key") continue;
+      if (k.startsWith("on") && k.length > 2) continue;
+      if (k.startsWith("data-")) continue;
+      const v = props[k];
+      try {
+        if (k === "class" || k === "className") {
+          if (el.className !== String(v)) {
+            hasPropChanges = true;
+            break;
+          }
+        } else if (k === "value" || k === "checked") {
+          if (el[k] !== v) {
+            hasPropChanges = true;
+            break;
+          }
+        } else {
+          const attr = el.getAttribute(k);
+          if (v === void 0 || v === null || v === false) {
+            if (attr !== null) {
+              hasPropChanges = true;
+              break;
+            }
+          } else if (String(v) !== attr) {
+            hasPropChanges = true;
+            break;
+          }
+        }
+      } catch {
+        hasPropChanges = true;
+        break;
+      }
+    }
+    if (hasPropChanges) break;
+  }
+  const useFastPath = (cheapMoveTrigger || lisTrigger) && !hasPropChanges && !hasPropsPresent;
+  return {
+    useFastPath,
+    totalKeyed,
+    moveCount,
+    lisLen,
+    hasPropChanges
+  };
+}
+function reconcileKeyedChildren(parent, newChildren, oldKeyMap) {
+  const newKeyMap = /* @__PURE__ */ new Map();
+  const keyedVnodes = [];
+  const unkeyedVnodes = [];
+  for (let i = 0; i < newChildren.length; i++) {
+    const child = newChildren[i];
+    if (_isDOMElement(child) && child.key !== void 0) {
+      keyedVnodes.push({ key: child.key, vnode: child });
+    } else {
+      unkeyedVnodes.push(child);
+    }
+  }
+  const totalKeyed = keyedVnodes.length;
+  const newKeyOrder = keyedVnodes.map((kv) => kv.key);
+  const oldKeyOrder = oldKeyMap ? Array.from(oldKeyMap.keys()) : [];
+  let moveCount = 0;
+  for (let i = 0; i < newKeyOrder.length; i++) {
+    const k2 = newKeyOrder[i];
+    if (i >= oldKeyOrder.length || oldKeyOrder[i] !== k2 || !oldKeyMap?.has(k2)) {
+      moveCount++;
+    }
+  }
+  let hasPropChanges = false;
+  for (let i = 0; i < keyedVnodes.length; i++) {
+    const { key, vnode } = keyedVnodes[i];
+    const el = oldKeyMap?.get(key);
+    if (!el || !_isDOMElement(vnode)) continue;
+    const props = vnode.props || {};
+    for (const k2 of Object.keys(props)) {
+      if (k2 === "children" || k2 === "key") continue;
+      if (k2.startsWith("on") && k2.length > 2) {
+        continue;
+      }
+      const v = props[k2];
+      try {
+        if (k2 === "class" || k2 === "className") {
+          if (el.className !== String(v)) {
+            logger.warn("[Askr][FASTPATH][DEV] prop mismatch", {
+              key,
+              prop: k2,
+              expected: String(v),
+              actual: el.className
+            });
+            hasPropChanges = true;
+            break;
+          }
+        } else if (k2 === "value" || k2 === "checked") {
+          if (el[k2] !== v) {
+            logger.warn("[Askr][FASTPATH][DEV] prop mismatch", {
+              key,
+              prop: k2,
+              expected: v,
+              actual: el[k2]
+            });
+            hasPropChanges = true;
+            break;
+          }
+        } else {
+          const attr = el.getAttribute(k2);
+          if (v === void 0 || v === null || v === false) {
+            if (attr !== null) {
+              logger.warn(
+                "[Askr][FASTPATH][DEV] prop mismatch (missing attr)",
+                {
+                  key,
+                  prop: k2,
+                  expected: v,
+                  actual: attr
+                }
+              );
+              hasPropChanges = true;
+              break;
+            }
+          } else if (String(v) !== attr) {
+            logger.warn("[Askr][FASTPATH][DEV] prop mismatch (attr diff)", {
+              key,
+              prop: k2,
+              expected: String(v),
+              actual: attr
+            });
+            hasPropChanges = true;
+            break;
+          }
+        }
+      } catch {
+        hasPropChanges = true;
+        break;
+      }
+    }
+    if (hasPropChanges) break;
+  }
+  const decision = isKeyedReorderFastPathEligible(
+    parent,
+    newChildren,
+    oldKeyMap
+  );
+  const useFastPath = decision.useFastPath;
+  logger.warn("[Askr][FASTPATH][DEV] decision", decision);
+  try {
+    const hugeThreshold = Number(process.env.ASKR_BULK_HUGE_THRESHOLD) || 2048;
+    if (!useFastPath && keyedVnodes.length >= hugeThreshold) {
+      let allSimple = true;
+      for (let i = 0; i < keyedVnodes.length; i++) {
+        const vnode = keyedVnodes[i].vnode;
+        if (!_isDOMElement(vnode)) {
+          allSimple = false;
+          break;
+        }
+        const dv = vnode;
+        if (typeof dv.type !== "string") {
+          allSimple = false;
+          break;
+        }
+        const ch = dv.children || dv.props?.children;
+        if (ch === void 0) continue;
+        if (Array.isArray(ch)) {
+          if (ch.length !== 1 || typeof ch[0] !== "string" && typeof ch[0] !== "number") {
+            allSimple = false;
+            break;
+          }
+        } else if (typeof ch !== "string" && typeof ch !== "number") {
+          allSimple = false;
+          break;
+        }
+      }
+      if (allSimple) {
+        logger.warn("[Askr][FASTPATH] applying huge-list positional fallback");
+        try {
+          if (isBulkCommitActive2()) markFastPathApplied(parent);
+        } catch (e) {
+          void e;
+        }
+        const stats = performBulkPositionalKeyedTextUpdate(parent, keyedVnodes);
+        if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+          try {
+            const gl = globalThis;
+            gl.__ASKR_LAST_FASTPATH_STATS = stats;
+            const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
+            counters.bulkKeyedHugeFallback = (counters.bulkKeyedHugeFallback || 0) + 1;
+            gl.__ASKR_FASTPATH_COUNTERS = counters;
+            gl.__ASKR_BULK_DIAG = {
+              phase: "bulk-keyed-huge-fallback",
+              stats
+            };
+          } catch (e) {
+            void e;
+          }
+        }
+        return newKeyMap;
+      }
+    }
+  } catch (e) {
+    void e;
+  }
+  if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+    try {
+      const gl = globalThis;
+      gl.__ASKR_BULK_DIAG = {
+        phase: "keyed-decision",
+        decision,
+        totalKeyed,
+        oldKeyMapSize: oldKeyMap?.size ?? 0
+      };
+    } catch (e) {
+      void e;
+    }
+  }
+  let allSimpleText = false;
+  try {
+    if (keyedVnodes.length >= (Number(process.env.ASKR_BULK_TEXT_THRESHOLD) || 1024)) {
+      let missing = 0;
+      try {
+        const present = /* @__PURE__ */ new Set();
+        const parentChildren2 = Array.from(parent.children);
+        for (let i = 0; i < parentChildren2.length; i++) {
+          const attr = parentChildren2[i].getAttribute("data-key");
+          if (attr !== null) {
+            present.add(attr);
+            const n = Number(attr);
+            if (!Number.isNaN(n)) present.add(n);
+          }
+        }
+        for (let i = 0; i < keyedVnodes.length; i++) {
+          const k2 = keyedVnodes[i].key;
+          if (!present.has(k2)) missing++;
+        }
+      } catch {
+        missing = 0;
+      }
+      allSimpleText = keyedVnodes.length > 0 && keyedVnodes.every(({ vnode }) => {
+        if (!_isDOMElement(vnode)) return false;
+        const dv = vnode;
+        if (typeof dv.type !== "string") return false;
+        const ch = dv.children || dv.props?.children;
+        if (ch === void 0) return true;
+        if (Array.isArray(ch)) {
+          return ch.length === 1 && (typeof ch[0] === "string" || typeof ch[0] === "number");
+        }
+        return typeof ch === "string" || typeof ch === "number";
+      });
+      let hasPropsPresent = false;
+      for (let i = 0; i < keyedVnodes.length; i++) {
+        const vnode = keyedVnodes[i].vnode;
+        if (!_isDOMElement(vnode)) continue;
+        const props = vnode.props || {};
+        for (const k2 of Object.keys(props)) {
+          if (k2 === "children" || k2 === "key") continue;
+          if (k2.startsWith("on") && k2.length > 2) continue;
+          if (k2.startsWith("data-")) continue;
+          hasPropsPresent = true;
+          break;
+        }
+        if (hasPropsPresent) break;
+      }
+      const missingRatio = missing / Math.max(1, keyedVnodes.length);
+      if (missingRatio > 0.5 && allSimpleText && !hasPropsPresent) {
+        logger.warn(
+          "[Askr][FASTPATH] switching to positional bulk keyed fast-path due to missing keys ratio",
+          missingRatio
+        );
+        try {
+          if (isBulkCommitActive2()) markFastPathApplied(parent);
+        } catch (e) {
+          void e;
+        }
+        const stats = performBulkPositionalKeyedTextUpdate(parent, keyedVnodes);
+        if (process.env.NODE_ENV !== "production") {
+          try {
+            const gl = globalThis;
+            gl.__ASKR_LAST_FASTPATH_STATS = stats;
+            try {
+              _reconcilerRecordedParents.add(parent);
+            } catch (e) {
+              void e;
+            }
+            gl.__ASKR_LAST_FASTPATH_COMMIT_COUNT = 1;
+            const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
+            counters.bulkKeyedPositionalHits = (counters.bulkKeyedPositionalHits || 0) + 1;
+            gl.__ASKR_FASTPATH_COUNTERS = counters;
+          } catch (e) {
+            void e;
+          }
+        }
+        return newKeyMap;
+      }
+    }
+  } catch (e) {
+    void e;
+  }
+  if (!useFastPath && typeof globalThis !== "undefined") {
+    try {
+      let parentFastpathApplied = false;
+      try {
+        parentFastpathApplied = isFastPathApplied(parent);
+      } catch {
+        parentFastpathApplied = false;
+      }
+      if (!parentFastpathApplied) {
+        const gl = globalThis;
+        try {
+          if (_reconcilerRecordedParents.has(parent)) {
+            _reconcilerRecordedParents.delete(parent);
+          } else {
+            delete gl.__ASKR_LAST_FASTPATH_STATS;
+            delete gl.__ASKR_LAST_FASTPATH_REUSED;
+          }
+        } catch {
+          delete gl.__ASKR_LAST_FASTPATH_STATS;
+          delete gl.__ASKR_LAST_FASTPATH_REUSED;
+        }
+      }
+    } catch (e) {
+      void e;
+    }
+  }
+  let _triedPositionalReuse = false;
+  try {
+    const bulkTextThreshold = Number(process.env.ASKR_BULK_TEXT_THRESHOLD) || 1024;
+    if (!useFastPath && keyedVnodes.length >= bulkTextThreshold && allSimpleText && !hasPropChanges) {
+      try {
+        if (isFastPathApplied(parent)) {
+          logger.warn(
+            "[Askr][FASTPATH] fast-path already applied on parent; skipping"
+          );
+          return newKeyMap;
+        }
+      } catch (e) {
+        void e;
+      }
+      let stable = true;
+      try {
+        const parentChildren2 = Array.from(parent.children);
+        if (parentChildren2.length === keyedVnodes.length) {
+          const allSimple = keyedVnodes.every(({ vnode }) => {
+            if (!_isDOMElement(vnode)) return false;
+            const dv = vnode;
+            if (typeof dv.type !== "string") return false;
+            const ch = dv.children || dv.props?.children;
+            if (ch === void 0) return true;
+            if (Array.isArray(ch)) {
+              return ch.length === 1 && (typeof ch[0] === "string" || typeof ch[0] === "number");
+            }
+            return typeof ch === "string" || typeof ch === "number";
+          });
+          if (allSimple || process.env.ASKR_FORCE_BULK_POSREUSE === "1") {
+            logger.warn(
+              "[Askr][FASTPATH] len-match heuristic triggered (positional bulk)"
+            );
+            if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+              try {
+                const gl = globalThis;
+                gl.__ASKR_BULK_DIAG = {
+                  phase: "bulk-keyed-positional-trigger-lenmatch-early",
+                  totalKeyed: keyedVnodes.length,
+                  allSimple,
+                  forced: process.env.ASKR_FORCE_BULK_POSREUSE === "1"
+                };
+              } catch (e) {
+                void e;
+              }
+            }
+            try {
+              if (isBulkCommitActive2()) markFastPathApplied(parent);
+            } catch (e) {
+              void e;
+            }
+            const stats = performBulkPositionalKeyedTextUpdate(
+              parent,
+              keyedVnodes
+            );
+            if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+              try {
+                const gl = globalThis;
+                gl.__ASKR_LAST_FASTPATH_STATS = stats;
+                gl.__ASKR_BULK_DIAG = {
+                  phase: "bulk-keyed-positional-applied",
+                  stats
+                };
+                const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
+                counters.bulkKeyedPositionalHits = (counters.bulkKeyedPositionalHits || 0) + 1;
+                if (process.env.ASKR_FORCE_BULK_POSREUSE === "1")
+                  counters.bulkKeyedPositionalForced = (counters.bulkKeyedPositionalForced || 0) + 1;
+                gl.__ASKR_FASTPATH_COUNTERS = counters;
+              } catch (e) {
+                void e;
+              }
+            }
+            return newKeyMap;
+          }
+        }
+        if (parentChildren2.length !== keyedVnodes.length) stable = false;
+        else {
+          let keyMismatches = 0;
+          for (let i = 0; i < keyedVnodes.length; i++) {
+            const k2 = keyedVnodes[i].key;
+            const ch = parentChildren2[i];
+            if (!ch) {
+              stable = false;
+              break;
+            }
+            const attr = ch.getAttribute("data-key");
+            if (attr === null) {
+              stable = false;
+              break;
+            }
+            if (String(k2) !== attr && String(Number(attr)) !== String(k2)) {
+              keyMismatches++;
+            }
+          }
+          if (stable) {
+            if (keyMismatches === 0) {
+              logger.warn(
+                "[Askr][FASTPATH] applying bulk keyed text fast-path (stable keys)"
+              );
+              if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+                try {
+                  const gl = globalThis;
+                  gl.__ASKR_BULK_DIAG = {
+                    phase: "bulk-keyed-stable-trigger",
+                    totalKeyed: keyedVnodes.length,
+                    hasPropChanges
+                  };
+                } catch (e) {
+                  void e;
+                }
+              }
+              try {
+                if (isBulkCommitActive2()) markFastPathApplied(parent);
+              } catch (e) {
+                void e;
+              }
+              const stats = performBulkKeyedTextReplace(
+                parent,
+                keyedVnodes,
+                oldKeyMap
+              );
+              if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+                try {
+                  const gl = globalThis;
+                  gl.__ASKR_LAST_FASTPATH_STATS = stats;
+                  gl.__ASKR_BULK_DIAG = {
+                    phase: "bulk-keyed-applied",
+                    stats
+                  };
+                  const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
+                  counters.bulkKeyedTextHits = (counters.bulkKeyedTextHits || 0) + 1;
+                  gl.__ASKR_FASTPATH_COUNTERS = counters;
+                } catch (e) {
+                  void e;
+                }
+              }
+              return newKeyMap;
+            }
+            if (parentChildren2.length === keyedVnodes.length) {
+              logger.warn(
+                "[Askr][FASTPATH] applying bulk keyed positional text fast-path (len-match)"
+              );
+              if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+                try {
+                  const gl = globalThis;
+                  gl.__ASKR_BULK_DIAG = {
+                    phase: "bulk-keyed-positional-trigger-lenmatch",
+                    totalKeyed: keyedVnodes.length,
+                    keyMismatches
+                  };
+                } catch (e) {
+                  void e;
+                }
+              }
+              try {
+                if (isBulkCommitActive2()) markFastPathApplied(parent);
+              } catch (e) {
+                void e;
+              }
+              const stats = performBulkPositionalKeyedTextUpdate(
+                parent,
+                keyedVnodes
+              );
+              if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+                try {
+                  const gl = globalThis;
+                  gl.__ASKR_LAST_FASTPATH_STATS = stats;
+                  gl.__ASKR_BULK_DIAG = {
+                    phase: "bulk-keyed-positional-applied",
+                    stats
+                  };
+                  const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
+                  counters.bulkKeyedPositionalHits = (counters.bulkKeyedPositionalHits || 0) + 1;
+                  gl.__ASKR_FASTPATH_COUNTERS = counters;
+                } catch (e) {
+                  void e;
+                }
+              }
+              return newKeyMap;
+            }
+            const mismatchRatio = keyMismatches / keyedVnodes.length;
+            const POSITIONAL_THRESHOLD = 0.5;
+            if (mismatchRatio > POSITIONAL_THRESHOLD) {
+              logger.warn(
+                "[Askr][FASTPATH] applying bulk keyed positional text fast-path"
+              );
+              if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+                try {
+                  globalThis.__ASKR_BULK_DIAG = {
+                    phase: "bulk-keyed-positional-trigger",
+                    totalKeyed: keyedVnodes.length,
+                    keyMismatches
+                  };
+                } catch (e) {
+                  void e;
+                }
+              }
+              try {
+                if (isBulkCommitActive2()) markFastPathApplied(parent);
+              } catch (e) {
+                void e;
+              }
+              const stats = performBulkPositionalKeyedTextUpdate(
+                parent,
+                keyedVnodes
+              );
+              if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+                try {
+                  const gl = globalThis;
+                  gl.__ASKR_LAST_FASTPATH_STATS = stats;
+                  gl.__ASKR_BULK_DIAG = {
+                    phase: "bulk-keyed-positional-applied",
+                    stats
+                  };
+                  const counters = gl.__ASKR_FASTPATH_COUNTERS || {};
+                  counters.bulkKeyedPositionalHits = (counters.bulkKeyedPositionalHits || 0) + 1;
+                  gl.__ASKR_FASTPATH_COUNTERS = counters;
+                } catch (e) {
+                  void e;
+                }
+              }
+              return newKeyMap;
+            }
+          }
+        }
+      } catch {
+        stable = false;
+      }
+    }
+  } catch (e) {
+    void e;
+  }
+  if (!useFastPath) {
+    const totalKeyed2 = keyedVnodes.length;
+    const candidates = newChildren.filter(
+      (c) => _isDOMElement(c) && typeof c.type === "string"
+    );
+    const smallListPositionalReuseEligible = candidates.length > 0 && candidates.length <= 64 && parent.children.length === candidates.length && candidates.every((vnode) => {
+      const children = vnode.children || vnode.props?.children;
+      if (Array.isArray(children)) {
+        return children.length === 1 && (typeof children[0] === "string" || typeof children[0] === "number");
+      }
+      return children === void 0 || typeof children === "string" || typeof children === "number";
+    });
+    try {
+      if (smallListPositionalReuseEligible) {
+        let eligible = true;
+        for (let i = 0; i < totalKeyed2; i++) {
+          const vnode = keyedVnodes[i].vnode;
+          if (!_isDOMElement(vnode) || typeof vnode.type !== "string") {
+            eligible = false;
+            break;
+          }
+          const children = vnode.children || vnode.props?.children;
+          if (Array.isArray(children)) {
+            if (children.length !== 1) {
+              eligible = false;
+              break;
+            }
+            const c = children[0];
+            if (typeof c !== "string" && typeof c !== "number") {
+              eligible = false;
+              break;
+            }
+          } else if (children !== void 0 && typeof children !== "string" && typeof children !== "number") {
+            eligible = false;
+            break;
+          }
+        }
+        const anyKeyMatches = !!oldKeyMap && keyedVnodes.some((kv) => oldKeyMap.has(kv.key));
+        if (anyKeyMatches) {
+          eligible = false;
+        }
+        if (eligible || process.env.ASKR_FORCE_POSREUSE === "1") {
+          _triedPositionalReuse = true;
+          if (process.env.ASKR_FORCE_POSREUSE === "1") {
+            logger.warn(
+              "[Askr][POSREUSE][FORCED] forcing positional reuse path for testing"
+            );
+          } else {
+            logger.warn("[Askr][POSREUSE] positional reuse heuristic applied");
+          }
+          const existingChildren = parent.children;
+          for (let i = 0; i < totalKeyed2; i++) {
+            const { key, vnode } = keyedVnodes[i];
+            const current2 = existingChildren[i];
+            if (current2 && _isDOMElement(vnode)) {
+              const vnodeType = vnode.type;
+              if (current2.tagName.toLowerCase() === vnodeType.toLowerCase()) {
+                updateElementFromVnode(current2, vnode);
+                newKeyMap.set(key, current2);
+                continue;
+              }
+            }
+            const newEl = createDOMNode(vnode);
+            if (newEl instanceof Element) {
+              if (current2) {
+                cleanupInstanceIfPresent(current2);
+                parent.replaceChild(newEl, current2);
+              } else parent.appendChild(newEl);
+              newKeyMap.set(key, newEl);
+            }
+          }
+          for (const vnode of unkeyedVnodes) {
+            const newEl = createDOMNode(vnode);
+            if (newEl) parent.appendChild(newEl);
+          }
+          return newKeyMap;
+        }
+      }
+    } catch {
+    }
+  }
+  if (useFastPath) {
+    if (!isSchedulerExecuting()) {
+      logger.warn(
+        "[Askr][FASTPATH][DEV] Fast-path reconciliation invoked outside scheduler execution"
+      );
+    }
+    let parentChildrenArr;
+    let localOldKeyMap;
+    if (totalKeyed <= 20) {
+      try {
+        const pc = parent.children;
+        parentChildrenArr = new Array(pc.length);
+        for (let i = 0; i < pc.length; i++)
+          parentChildrenArr[i] = pc[i];
+      } catch {
+        parentChildrenArr = void 0;
+      }
+    } else {
+      localOldKeyMap = /* @__PURE__ */ new Map();
+      try {
+        const parentChildren2 = Array.from(parent.children);
+        for (let i = 0; i < parentChildren2.length; i++) {
+          const ch = parentChildren2[i];
+          const k2 = ch.getAttribute("data-key");
+          if (k2 !== null) {
+            localOldKeyMap.set(k2, ch);
+            const n = Number(k2);
+            if (!Number.isNaN(n)) localOldKeyMap.set(n, ch);
+          }
+        }
+      } catch {
+        localOldKeyMap = void 0;
+      }
+    }
+    logger.warn(
+      "[Askr][FASTPATH] oldKeyMap size:",
+      oldKeyMap?.size ?? 0,
+      "localOldKeyMap size:",
+      localOldKeyMap?.size
+    );
+    const tLookupStart = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+    const finalNodes = [];
+    let mapLookups = 0;
+    let createdNodes = 0;
+    let reusedCount = 0;
+    for (let i = 0; i < keyedVnodes.length; i++) {
+      const { key, vnode } = keyedVnodes[i];
+      mapLookups++;
+      let el;
+      if (totalKeyed <= 20 && parentChildrenArr) {
+        const ks = String(key);
+        for (let j = 0; j < parentChildrenArr.length; j++) {
+          const ch = parentChildrenArr[j];
+          const k2 = ch.getAttribute("data-key");
+          if (k2 !== null && (k2 === ks || Number(k2) === key)) {
+            el = ch;
+            break;
+          }
+        }
+        if (!el) el = oldKeyMap?.get(key);
+      } else {
+        el = localOldKeyMap?.get(key) ?? oldKeyMap?.get(key);
+      }
+      if (el) {
+        finalNodes.push(el);
+        reusedCount++;
+      } else {
+        const newEl = createDOMNode(vnode);
+        if (newEl) {
+          finalNodes.push(newEl);
+          createdNodes++;
+        }
+      }
+    }
+    for (const vnode of unkeyedVnodes) {
+      const newEl = createDOMNode(vnode);
+      if (newEl) {
+        finalNodes.push(newEl);
+        createdNodes++;
+      }
+    }
+    const t_lookup = typeof performance !== "undefined" && performance.now ? performance.now() - tLookupStart : 0;
+    if (process.env.ASKR_FASTPATH_GUARD === "1") {
+      const replaceChildrenCount = 0;
+      const otherMutationCount = 0;
+      const orig = {};
+      const elProto = Element.prototype;
+      const nodeProto = Node.prototype;
+      const removeFn = (() => {
+        if (typeof document === "undefined" || typeof document.createElement !== "function")
+          return void 0;
+        try {
+          const el = document.createElement("div");
+          return typeof el.remove === "function" ? el.remove : void 0;
+        } catch {
+          return void 0;
+        }
+      })();
+      if (elProto.replaceChildren)
+        orig.replaceChildren = elProto.replaceChildren;
+      if (nodeProto.appendChild) orig.appendChild = nodeProto.appendChild;
+      if (nodeProto.insertBefore) orig.insertBefore = nodeProto.insertBefore;
+      if (nodeProto.removeChild) orig.removeChild = nodeProto.removeChild;
+      if (nodeProto.replaceChild) orig.replaceChild = nodeProto.replaceChild;
+      if (removeFn) orig.remove = removeFn;
+      let violation = false;
+      try {
+        const fragment = document.createDocumentFragment();
+        for (let i = 0; i < finalNodes.length; i++)
+          fragment.appendChild(finalNodes[i]);
+        let commitCount = 0;
+        commitCount++;
+        parent.replaceChildren(fragment);
+        if (typeof globalThis !== "undefined") {
+          globalThis["__ASKR_LAST_FASTPATH_COMMIT_COUNT"] = commitCount;
+        }
+      } finally {
+        violation = otherMutationCount !== 0 || replaceChildrenCount < 1;
+      }
+      if (violation) {
+        logger.error(
+          "[Askr][DEV] Fast-path structural mutation invariant violated:",
+          {
+            replaceChildrenCount,
+            otherMutationCount
+          }
+        );
+        throw new Error(
+          "Fast-path must perform a single structural replacement (replaceChildren) and no other structural mutations"
+        );
+      }
+    } else {
+      const tFragmentStart = Date.now();
+      const fragment = document.createDocumentFragment();
+      let fragmentAppendCount = 0;
+      for (let i = 0; i < finalNodes.length; i++) {
+        fragment.appendChild(finalNodes[i]);
+        fragmentAppendCount++;
+      }
+      const t_fragment = Date.now() - tFragmentStart;
+      const schedBefore = process.env.NODE_ENV !== "production" ? globalScheduler.getState() : null;
+      const wasExecuting = process.env.NODE_ENV !== "production" ? isSchedulerExecuting() : false;
+      const tCommitStart = Date.now();
+      if (process.env.NODE_ENV !== "production") {
+      }
+      let commitCount = 0;
+      commitCount++;
+      try {
+        const existing = Array.from(parent.childNodes);
+        for (const n of existing) cleanupInstanceIfPresent(n);
+      } catch (e) {
+        void e;
+      }
+      try {
+        const existing = Array.from(parent.childNodes);
+        for (const n of existing) cleanupInstanceIfPresent(n);
+      } catch (e) {
+        void e;
+      }
+      parent.replaceChildren(fragment);
+      if (typeof globalThis !== "undefined") {
+        globalThis["__ASKR_LAST_FASTPATH_COMMIT_COUNT"] = commitCount;
+      }
+      const t_commit = Date.now() - tCommitStart;
+      if (process.env.NODE_ENV !== "production") {
+        const schedAfter = globalScheduler.getState();
+        if (!wasExecuting) {
+          logger.warn(
+            "[Askr][FASTPATH][DEV] Fast-path commit invoked outside scheduler execution"
+          );
+        }
+        if (schedBefore && schedAfter) {
+          if (schedBefore.taskCount !== schedAfter.taskCount) {
+            logger.error(
+              "[Askr][FASTPATH][DEV] Scheduler tasks were enqueued during fast-path commit",
+              {
+                before: schedBefore,
+                after: schedAfter
+              }
+            );
+            throw new Error("Fast-path must not enqueue scheduler tasks");
+          }
+        }
+        const parentNodes = Array.from(parent.childNodes);
+        if (parentNodes.length !== finalNodes.length) {
+          logger.error("[Askr][FASTPATH][DEV] Parent child count mismatch", {
+            parentCount: parentNodes.length,
+            expected: finalNodes.length
+          });
+          throw new Error(
+            "Fast-path must perform a single structural replacement"
+          );
+        }
+        for (let i = 0; i < finalNodes.length; i++) {
+          if (parentNodes[i] !== finalNodes[i]) {
+            logger.error(
+              "[Askr][FASTPATH][DEV] Final DOM order mismatch at index",
+              i,
+              {
+                expected: finalNodes[i],
+                found: parentNodes[i]
+              }
+            );
+            throw new Error(
+              "Fast-path final DOM order does not match expected nodes"
+            );
+          }
+        }
+      }
+      const tBookkeepingStart = Date.now();
+      for (let i = 0; i < keyedVnodes.length; i++) {
+        const key = keyedVnodes[i].key;
+        const node = finalNodes[i];
+        if (node instanceof Element) newKeyMap.set(key, node);
+      }
+      const t_bookkeeping = Date.now() - tBookkeepingStart;
+      if (process.env.ASKR_FASTPATH_TRACE === "1" || process.env.NODE_ENV !== "production") {
+        const stats = {
+          n: totalKeyed,
+          moves: moveCount,
+          lisLen: 0,
+          t_lookup,
+          t_fragment,
+          t_commit,
+          t_bookkeeping,
+          fragmentAppendCount,
+          mapLookups,
+          createdNodes,
+          reusedCount
+        };
+        if (typeof globalThis !== "undefined") {
+          const _g = globalThis;
+          _g["__ASKR_LAST_FASTPATH_STATS"] = stats;
+          _g["__ASKR_LAST_FASTPATH_REUSED"] = reusedCount > 0;
+          const historyKey = "__ASKR_LAST_FASTPATH_HISTORY";
+          let hist = _g[historyKey];
+          if (!hist) {
+            hist = [];
+            _g[historyKey] = hist;
+          }
+          hist.push(stats);
+        }
+        logger.warn("[Askr][FASTPATH]", JSON.stringify(stats));
+      }
+    }
+    return newKeyMap;
+  }
+  const parentChildren = Array.from(parent.children);
+  const positions = new Array(keyedVnodes.length).fill(-1);
+  for (let i = 0; i < keyedVnodes.length; i++) {
+    const key = keyedVnodes[i].key;
+    const el = oldKeyMap?.get(key);
+    if (el && el.parentElement === parent) {
+      positions[i] = parentChildren.indexOf(el);
+    }
+  }
+  const tailsStart = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+  const keepSet = /* @__PURE__ */ new Set();
+  const tails = [];
+  const tailsIdx = [];
+  const prev = new Array(positions.length).fill(-1);
+  for (let i = 0; i < positions.length; i++) {
+    const pos = positions[i];
+    if (pos === -1) continue;
+    let lo = 0;
+    let hi = tails.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (tails[mid] < pos) lo = mid + 1;
+      else hi = mid;
+    }
+    if (lo === tails.length) {
+      tails.push(pos);
+      tailsIdx.push(i);
+    } else {
+      tails[lo] = pos;
+      tailsIdx[lo] = i;
+    }
+    prev[i] = lo > 0 ? tailsIdx[lo - 1] : -1;
+  }
+  let k = tailsIdx.length ? tailsIdx[tailsIdx.length - 1] : -1;
+  while (k !== -1) {
+    keepSet.add(k);
+    k = prev[k];
+  }
+  const tLIS = (typeof performance !== "undefined" && performance.now ? performance.now() : Date.now()) - tailsStart;
+  if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+    try {
+      const prev2 = globalThis.__ASKR_BULK_DIAG;
+      globalThis.__ASKR_BULK_DIAG = {
+        phase: "keyed-fallback-lis",
+        positionsFound: positions.filter((p) => p !== -1).length,
+        keepCount: keepSet.size,
+        tLIS,
+        previousDecision: prev2?.decision
+      };
+    } catch (e) {
+      void e;
+    }
+  }
+  let anchor = parent.firstChild;
+  for (let i = 0; i < keyedVnodes.length; i++) {
+    const { key, vnode } = keyedVnodes[i];
+    const el = oldKeyMap?.get(key);
+    if (el && el.parentElement === parent) {
+      if (keepSet.has(i)) {
+        if (anchor === el) {
+          anchor = el.nextSibling;
+        }
+        updateElementFromVnode(el, vnode);
+        newKeyMap.set(key, el);
+      } else {
+        parent.insertBefore(el, anchor);
+        updateElementFromVnode(el, vnode);
+        newKeyMap.set(key, el);
+        anchor = el.nextSibling;
+      }
+    } else {
+      const newEl = createDOMNode(vnode);
+      if (newEl instanceof Element) {
+        parent.insertBefore(newEl, anchor);
+        newKeyMap.set(key, newEl);
+        anchor = newEl.nextSibling;
+      }
+    }
+  }
+  for (const vnode of unkeyedVnodes) {
+    const newEl = createDOMNode(vnode);
+    if (newEl) {
+      parent.appendChild(newEl);
+    }
+  }
+  return newKeyMap;
+}
+function performBulkKeyedTextReplace(parent, keyedVnodes, oldKeyMap) {
+  const total = keyedVnodes.length;
+  const finalNodes = [];
+  let reused = 0;
+  let created = 0;
+  const t0 = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+  for (let i = 0; i < total; i++) {
+    const { key, vnode } = keyedVnodes[i];
+    const el = oldKeyMap?.get(key);
+    if (el && _isDOMElement(vnode) && typeof vnode.type === "string") {
+      const children = vnode.children || vnode.props?.children;
+      if (typeof children === "string" || typeof children === "number") {
+        if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
+          el.firstChild.data = String(children);
+        } else {
+          el.textContent = String(children);
+        }
+      } else if (Array.isArray(children) && children.length === 1 && (typeof children[0] === "string" || typeof children[0] === "number")) {
+        if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
+          el.firstChild.data = String(children[0]);
+        } else {
+          el.textContent = String(children[0]);
+        }
+      } else {
+        updateElementFromVnode(el, vnode);
+      }
+      finalNodes.push(el);
+      reused++;
+    } else {
+      const dom = createDOMNode(vnode);
+      if (dom) {
+        finalNodes.push(dom);
+        created++;
+      }
+    }
+  }
+  try {
+    const toRemove = Array.from(parent.childNodes).filter(
+      (n) => !finalNodes.includes(n)
+    );
+    for (const n of toRemove) cleanupInstanceIfPresent(n);
+  } catch (e) {
+    void e;
+  }
+  const existingChildren = Array.from(parent.children);
+  const listenerSnapshots = new Array(existingChildren.length).fill(void 0);
+  try {
+    for (let i = 0; i < existingChildren.length; i++) {
+      const ch = existingChildren[i];
+      if (ch) {
+        const map = elementListeners.get(ch);
+        if (map && map.size > 0) {
+          const clone = /* @__PURE__ */ new Map();
+          for (const [k, v] of map) clone.set(k, v);
+          listenerSnapshots[i] = clone;
+        }
+      }
+    }
+  } catch (e) {
+    void e;
+  }
+  const fragment = document.createDocumentFragment();
+  for (let i = 0; i < finalNodes.length; i++)
+    fragment.appendChild(finalNodes[i]);
+  parent.replaceChildren(fragment);
+  try {
+    for (let i = 0; i < finalNodes.length; i++) {
+      const newNode = finalNodes[i];
+      const snapshot = listenerSnapshots[i];
+      if (snapshot && newNode instanceof Element) {
+        for (const [eventName, entry] of snapshot) {
+          const existing = elementListeners.get(newNode)?.get(eventName);
+          if (existing && existing.original === entry.original) continue;
+          newNode.addEventListener(eventName, entry.handler);
+          if (!elementListeners.has(newNode))
+            elementListeners.set(newNode, /* @__PURE__ */ new Map());
+          elementListeners.get(newNode).set(eventName, entry);
+        }
+      }
+    }
+  } catch (e) {
+    void e;
+  }
+  try {
+    keyedElements.delete(parent);
+  } catch (e) {
+    void e;
+  }
+  const t = typeof performance !== "undefined" && performance.now ? performance.now() - t0 : 0;
+  const stats = {
+    n: total,
+    reused,
+    created,
+    t
+  };
+  return stats;
+}
+function performBulkPositionalKeyedTextUpdate(parent, keyedVnodes) {
+  const total = keyedVnodes.length;
+  let reused = 0;
+  let updatedKeys = 0;
+  const t0 = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+  for (let i = 0; i < total; i++) {
+    const { key, vnode } = keyedVnodes[i];
+    const ch = parent.children[i];
+    if (ch && _isDOMElement(vnode) && typeof vnode.type === "string") {
+      const vnodeType = vnode.type;
+      if (ch.tagName.toLowerCase() === vnodeType.toLowerCase()) {
+        const children = vnode.children || vnode.props?.children;
+        if (typeof children === "string" || typeof children === "number") {
+          if (ch.childNodes.length === 1 && ch.firstChild?.nodeType === 3) {
+            ch.firstChild.data = String(children);
+          } else {
+            ch.textContent = String(children);
+          }
+        } else if (Array.isArray(children) && children.length === 1 && (typeof children[0] === "string" || typeof children[0] === "number")) {
+          if (ch.childNodes.length === 1 && ch.firstChild?.nodeType === 3) {
+            ch.firstChild.data = String(children[0]);
+          } else {
+            ch.textContent = String(children[0]);
+          }
+        } else {
+          updateElementFromVnode(ch, vnode);
+        }
+        try {
+          ch.setAttribute("data-key", String(key));
+          updatedKeys++;
+        } catch (e) {
+          void e;
+        }
+        reused++;
+        continue;
+      }
+    }
+    const dom = createDOMNode(vnode);
+    if (dom) {
+      const existing = parent.children[i];
+      if (existing) {
+        cleanupInstanceIfPresent(existing);
+        parent.replaceChild(dom, existing);
+      } else parent.appendChild(dom);
+    }
+  }
+  const t = typeof performance !== "undefined" && performance.now ? performance.now() - t0 : 0;
+  try {
+    const newKeyMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < total; i++) {
+      const k = keyedVnodes[i].key;
+      const ch = parent.children[i];
+      if (ch) newKeyMap.set(k, ch);
+    }
+    keyedElements.set(parent, newKeyMap);
+  } catch (e) {
+    void e;
+  }
+  const stats = {
+    n: total,
+    reused,
+    updatedKeys,
+    t
+  };
+  return stats;
+}
+function isBulkTextFastPathEligible(parent, newChildren) {
+  const threshold = Number(process.env.ASKR_BULK_TEXT_THRESHOLD) || 1024;
+  const requiredFraction = 0.8;
+  const total = Array.isArray(newChildren) ? newChildren.length : 0;
+  if (total < threshold) {
+    if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+      try {
+        globalThis.__ASKR_BULK_DIAG = {
+          phase: "bulk-unkeyed-eligible",
+          reason: "too-small",
+          total,
+          threshold
+        };
+      } catch (e) {
+        void e;
+      }
+    }
+    return false;
+  }
+  let simple = 0;
+  for (let i = 0; i < newChildren.length; i++) {
+    const c = newChildren[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") {
+        if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+          try {
+            globalThis.__ASKR_BULK_DIAG = {
+              phase: "bulk-unkeyed-eligible",
+              reason: "component-child",
+              index: i
+            };
+          } catch (e) {
+            void e;
+          }
+        }
+        return false;
+      }
+      if (typeof dv.type === "string") {
+        const children = dv.children || dv.props?.children;
+        if (!children) {
+          simple++;
+          continue;
+        }
+        if (Array.isArray(children)) {
+          if (children.length === 1 && (typeof children[0] === "string" || typeof children[0] === "number")) {
+            simple++;
+            continue;
+          }
+        } else if (typeof children === "string" || typeof children === "number") {
+          simple++;
+          continue;
+        }
+      }
+    }
+  }
+  const fraction = simple / total;
+  const eligible = fraction >= requiredFraction && parent.childNodes.length >= total;
+  if (process.env.NODE_ENV !== "production" || process.env.ASKR_FASTPATH_DEBUG === "1") {
+    try {
+      globalThis.__ASKR_BULK_DIAG = {
+        phase: "bulk-unkeyed-eligible",
+        total,
+        simple,
+        fraction,
+        requiredFraction,
+        eligible
+      };
+    } catch (e) {
+      void e;
+    }
+  }
+  return eligible;
+}
+function performBulkTextReplace(parent, newChildren) {
+  const t0 = typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
+  const existing = Array.from(parent.childNodes);
+  const finalNodes = [];
+  let reused = 0;
+  let created = 0;
+  for (let i = 0; i < newChildren.length; i++) {
+    const vnode = newChildren[i];
+    const existingNode = existing[i];
+    if (typeof vnode === "string" || typeof vnode === "number") {
+      const text = String(vnode);
+      if (existingNode && existingNode.nodeType === 3) {
+        existingNode.data = text;
+        finalNodes.push(existingNode);
+        reused++;
+      } else {
+        finalNodes.push(document.createTextNode(text));
+        created++;
+      }
+      continue;
+    }
+    if (typeof vnode === "object" && vnode !== null && "type" in vnode) {
+      if (typeof vnode.type === "string") {
+        const vtype = vnode.type;
+        if (existingNode && existingNode.nodeType === 1 && existingNode.tagName.toLowerCase() === vtype.toLowerCase()) {
+          const el = existingNode;
+          const children = vnode.children || vnode.props?.children;
+          if (typeof children === "string" || typeof children === "number") {
+            if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
+              el.firstChild.data = String(children);
+            } else {
+              el.textContent = String(children);
+            }
+          } else if (Array.isArray(children) && children.length === 1 && (typeof children[0] === "string" || typeof children[0] === "number")) {
+            if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
+              el.firstChild.data = String(children[0]);
+            } else {
+              el.textContent = String(children[0]);
+            }
+          } else {
+            updateElementFromVnode(el, vnode);
+          }
+          finalNodes.push(el);
+          reused++;
+          continue;
+        }
+        const dom2 = createDOMNode(vnode);
+        if (dom2) {
+          finalNodes.push(dom2);
+          created++;
+        }
+        continue;
+      }
+    }
+    const dom = createDOMNode(vnode);
+    if (dom) {
+      finalNodes.push(dom);
+      created++;
+    }
+  }
+  const tBuild = typeof performance !== "undefined" && performance.now ? performance.now() - t0 : 0;
+  try {
+    const toRemove = Array.from(parent.childNodes).filter(
+      (n) => !finalNodes.includes(n)
+    );
+    for (const n of toRemove) cleanupInstanceIfPresent(n);
+  } catch (e) {
+    void e;
+  }
+  const fragStart = Date.now();
+  const fragment = document.createDocumentFragment();
+  for (let i = 0; i < finalNodes.length; i++)
+    fragment.appendChild(finalNodes[i]);
+  parent.replaceChildren(fragment);
+  const tCommit = Date.now() - fragStart;
+  keyedElements.delete(parent);
+  const stats = {
+    n: newChildren.length,
+    reused,
+    created,
+    tBuild,
+    tCommit
+  };
+  return stats;
+}
+function updateElementFromVnode(el, vnode, updateChildren = true) {
+  if (!_isDOMElement(vnode)) {
+    return;
+  }
+  const props = vnode.props || {};
+  if (vnode.key !== void 0) {
+    el.setAttribute("data-key", String(vnode.key));
+  }
+  const existingListeners = elementListeners.get(el);
+  const desiredEventNames = /* @__PURE__ */ new Set();
+  for (const key in props) {
+    const value = props[key];
+    if (key === "children" || key === "key") continue;
+    if (value === void 0 || value === null || value === false) {
+      if (key === "class" || key === "className") {
+        el.className = "";
+      } else if (key.startsWith("on") && key.length > 2) {
+        const eventName = key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();
+        if (existingListeners && existingListeners.has(eventName)) {
+          const entry = existingListeners.get(eventName);
+          el.removeEventListener(eventName, entry.handler);
+          existingListeners.delete(eventName);
+        }
+        continue;
+      } 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 (key.startsWith("on") && key.length > 2) {
+      const eventName = key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();
+      desiredEventNames.add(eventName);
+      const existing = existingListeners?.get(eventName);
+      if (existing && existing.original === value) {
+        continue;
+      }
+      if (existing) {
+        el.removeEventListener(eventName, existing.handler);
+      }
+      const wrappedHandler = (event) => {
+        globalScheduler.setInHandler(true);
+        try {
+          value(event);
+        } catch (error) {
+          logger.error("[Askr] Event handler error:", error);
+        } finally {
+          globalScheduler.setInHandler(false);
+        }
+      };
+      el.addEventListener(eventName, wrappedHandler);
+      if (!elementListeners.has(el)) {
+        elementListeners.set(el, /* @__PURE__ */ new Map());
+      }
+      elementListeners.get(el).set(eventName, {
+        handler: wrappedHandler,
+        original: value
+      });
+    } else {
+      el.setAttribute(key, String(value));
+    }
+  }
+  if (existingListeners) {
+    for (const eventName of existingListeners.keys()) {
+      const entry = existingListeners.get(eventName);
+      if (!desiredEventNames.has(eventName)) {
+        el.removeEventListener(eventName, entry.handler);
+        existingListeners.delete(eventName);
+      }
+    }
+    if (existingListeners.size === 0) elementListeners.delete(el);
+  }
+  if (updateChildren) {
+    const children = vnode.children || props.children;
+    updateElementChildren(el, children);
+  }
+}
+function updateElementChildren(el, children) {
+  if (!children) {
+    el.textContent = "";
+    return;
+  }
+  if (!Array.isArray(children) && (typeof children === "string" || typeof children === "number")) {
+    if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
+      el.firstChild.data = String(children);
+    } else {
+      el.textContent = String(children);
+    }
+    return;
+  }
+  if (Array.isArray(children)) {
+    updateUnkeyedChildren(el, children);
+    return;
+  }
+  el.textContent = "";
+  const dom = createDOMNode(children);
+  if (dom) el.appendChild(dom);
+}
+function updateUnkeyedChildren(parent, newChildren) {
+  const existing = Array.from(parent.children);
+  if (existing.length === 0 && parent.childNodes.length > 0) {
+    parent.textContent = "";
+  }
+  const max = Math.max(existing.length, newChildren.length);
+  for (let i = 0; i < max; i++) {
+    const current2 = existing[i];
+    const next = newChildren[i];
+    if (next === void 0 && current2) {
+      cleanupInstanceIfPresent(current2);
+      current2.remove();
+      continue;
+    }
+    if (!current2 && next !== void 0) {
+      const dom = createDOMNode(next);
+      if (dom) parent.appendChild(dom);
+      continue;
+    }
+    if (!current2 || next === void 0) continue;
+    if (typeof next === "string" || typeof next === "number") {
+      current2.textContent = String(next);
+    } else if (_isDOMElement(next)) {
+      if (typeof next.type === "string") {
+        if (current2.tagName.toLowerCase() === next.type.toLowerCase()) {
+          updateElementFromVnode(current2, next);
+        } else {
+          const dom = createDOMNode(next);
+          if (dom) {
+            cleanupInstanceIfPresent(current2);
+            parent.replaceChild(dom, current2);
+          }
+        }
+      } else {
+        const dom = createDOMNode(next);
+        if (dom) {
+          cleanupInstanceIfPresent(current2);
+          parent.replaceChild(dom, current2);
+        }
+      }
+    } else {
+      const dom = createDOMNode(next);
+      if (dom) {
+        cleanupInstanceIfPresent(current2);
+        parent.replaceChild(dom, current2);
+      }
+    }
+  }
+}
+function createDOMNode(node) {
+  if (typeof node === "string") {
+    return document.createTextNode(node);
+  }
+  if (typeof node === "number") {
+    return document.createTextNode(String(node));
+  }
+  if (!node) {
+    return null;
+  }
+  if (Array.isArray(node)) {
+    const fragment = document.createDocumentFragment();
+    for (let i = 0; i < node.length; i++) {
+      const dom = createDOMNode(node[i]);
+      if (dom) fragment.appendChild(dom);
+    }
+    return fragment;
+  }
+  if (typeof node === "object" && node !== null && "type" in node) {
+    const type = node.type;
+    const props = node.props || {};
+    if (typeof type === "string") {
+      const el = document.createElement(type);
+      for (const key in props) {
+        const value = props[key];
+        if (key === "children" || key === "key") continue;
+        if (value === void 0 || value === null || value === false) continue;
+        if (key.startsWith("on") && key.length > 2) {
+          const eventName = key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();
+          const wrappedHandler = (event) => {
+            globalScheduler.setInHandler(true);
+            try {
+              value(event);
+            } catch (error) {
+              logger.error("[Askr] Event handler error:", error);
+            } finally {
+              globalScheduler.setInHandler(false);
+              const state2 = globalScheduler.getState();
+              if ((state2.queueLength ?? 0) > 0 && !state2.running) {
+                queueMicrotask(() => {
+                  try {
+                    if (!globalScheduler.isExecuting()) globalScheduler.flush();
+                  } catch (err) {
+                    setTimeout(() => {
+                      throw err;
+                    });
+                  }
+                });
+              }
+            }
+          };
+          el.addEventListener(eventName, wrappedHandler);
+          if (!elementListeners.has(el)) {
+            elementListeners.set(el, /* @__PURE__ */ new Map());
+          }
+          elementListeners.get(el).set(eventName, {
+            handler: wrappedHandler,
+            original: value
+          });
+        } else if (key === "class" || key === "className") {
+          el.className = String(value);
+        } else if (key === "value" || key === "checked") {
+          el[key] = value;
+          el.setAttribute(key, String(value));
+        } else {
+          el.setAttribute(key, String(value));
+        }
+      }
+      const vnodeKey = node.key;
+      if (vnodeKey !== void 0) {
+        el.setAttribute("data-key", String(vnodeKey));
+      }
+      const children = props.children || node.children;
+      if (children) {
+        if (Array.isArray(children)) {
+          if (process.env.NODE_ENV !== "production") {
+            let hasElements = false;
+            let hasKeys = false;
+            for (let i = 0; i < children.length; i++) {
+              const item = children[i];
+              if (typeof item === "object" && item !== null && "type" in item) {
+                hasElements = true;
+                const itemProps = item.props || {};
+                if ("key" in itemProps) {
+                  hasKeys = true;
+                  break;
+                }
+              }
+            }
+            if (hasElements && !hasKeys) {
+              if (typeof console !== "undefined") {
+                logger.warn(
+                  'Missing keys on dynamic lists. Each child in a list should have a unique "key" prop.'
+                );
+              }
+            }
+          }
+          for (let i = 0; i < children.length; i++) {
+            const dom = createDOMNode(children[i]);
+            if (dom) el.appendChild(dom);
+          }
+        } else {
+          const dom = createDOMNode(children);
+          if (dom) el.appendChild(dom);
+        }
+      }
+      return el;
+    }
+    if (typeof type === "function") {
+      const frame = node[CONTEXT_FRAME_SYMBOL];
+      const snapshot = frame || getCurrentContextFrame();
+      const componentFn = type;
+      const isAsync = componentFn.constructor.name === "AsyncFunction";
+      if (isAsync) {
+        throw new Error(
+          "Async components are not supported. Use resource() for async work."
+        );
+      }
+      const vnodeAny = node;
+      let childInstance = vnodeAny.__instance;
+      if (!childInstance) {
+        childInstance = createComponentInstance(
+          `comp-${Math.random().toString(36).slice(2, 7)}`,
+          componentFn,
+          props || {},
+          null
+        );
+        vnodeAny.__instance = childInstance;
+      }
+      if (snapshot) {
+        childInstance.ownerFrame = snapshot;
+      }
+      const result = withContext(
+        snapshot,
+        () => renderComponentInline(childInstance)
+      );
+      if (result instanceof Promise) {
+        throw new Error(
+          "Async components are not supported. Components must return synchronously."
+        );
+      }
+      const dom = withContext(snapshot, () => createDOMNode(result));
+      if (dom instanceof Element) {
+        mountInstanceInline(childInstance, dom);
+      } else {
+        const host = document.createElement("div");
+        mountInstanceInline(childInstance, host);
+      }
+      return dom;
+    }
+    if (typeof type === "symbol" && (type === Fragment || String(type) === "Symbol(Fragment)")) {
+      const fragment = document.createDocumentFragment();
+      const children = props.children || node.children;
+      if (children) {
+        if (Array.isArray(children)) {
+          for (let i = 0; i < children.length; i++) {
+            const dom = createDOMNode(children[i]);
+            if (dom) fragment.appendChild(dom);
+          }
+        } else {
+          const dom = createDOMNode(children);
+          if (dom) fragment.appendChild(dom);
+        }
+      }
+      return fragment;
+    }
+  }
+  return null;
+}
+var domRanges, elementListeners, keyedElements, _reconcilerRecordedParents;
+var init_dom = __esm({
+  "src/renderer/dom.ts"() {
+    "use strict";
+    init_scheduler();
+    init_fastlane();
+    init_logger();
+    init_jsx_runtime();
+    init_context();
+    init_component();
+    domRanges = /* @__PURE__ */ new WeakMap();
+    elementListeners = /* @__PURE__ */ new WeakMap();
+    keyedElements = /* @__PURE__ */ new WeakMap();
+    _reconcilerRecordedParents = /* @__PURE__ */ new WeakSet();
+    if (typeof globalThis !== "undefined") {
+      const _g = globalThis;
+      _g.__ASKR_RENDERER = {
+        evaluate,
+        isKeyedReorderFastPathEligible,
+        getKeyMapForElement
+      };
+    }
+  }
+});
+
+// src/runtime/component.ts
+var component_exports = {};
+__export(component_exports, {
+  cleanupComponent: () => cleanupComponent,
+  createComponentInstance: () => createComponentInstance,
+  executeComponent: () => executeComponent,
+  finalizeReadSubscriptions: () => finalizeReadSubscriptions,
+  getCurrentComponentInstance: () => getCurrentComponentInstance,
+  getCurrentInstance: () => getCurrentInstance,
+  getNextStateIndex: () => getNextStateIndex,
+  getSignal: () => getSignal,
+  mountComponent: () => mountComponent,
+  mountInstanceInline: () => mountInstanceInline,
+  registerMountOperation: () => registerMountOperation,
+  renderComponentInline: () => renderComponentInline,
+  setCurrentComponentInstance: () => setCurrentComponentInstance
+});
+function createComponentInstance(id, fn, props, target) {
+  const instance = {
+    id,
+    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,
+    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 setCurrentComponentInstance(instance) {
+  currentInstance = instance;
+}
+function registerMountOperation(operation) {
+  const instance = getCurrentComponentInstance();
+  if (instance) {
+    if (isBulkCommitActive2()) {
+      if (process.env.NODE_ENV !== "production") {
+        throw new Error(
+          "registerMountOperation called during bulk commit fast-lane"
+        );
+      }
+      return;
+    }
+    instance.mountOperations.push(operation);
+  }
+}
+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) {
+    void 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) {
+        try {
+          const wasFirstMount = !instance.mounted;
+          const oldInstance = currentInstance;
+          currentInstance = instance;
+          try {
+            evaluate(result, instance.target);
+          } finally {
+            currentInstance = oldInstance;
+          }
+          finalizeReadSubscriptions(instance);
+          instance.mounted = true;
+          if (wasFirstMount && instance.mountOperations.length > 0) {
+            executeMountOperations(instance);
+          }
+        } catch (renderError) {
+          instance.target.innerHTML = domSnapshot;
+          throw renderError;
+        }
+      }
+    });
+  }
+}
+function renderComponentInline(instance) {
+  const hadToken = instance._currentRenderToken !== void 0;
+  if (!hadToken) {
+    instance._currentRenderToken = ++_globalRenderCounter;
+    instance._pendingReadStates = /* @__PURE__ */ new Set();
+  }
+  try {
+    const result = executeComponentSync(instance);
+    if (!hadToken) {
+      finalizeReadSubscriptions(instance);
+    }
+    return result;
+  } finally {
+    if (!hadToken) {
+      instance._pendingReadStates = /* @__PURE__ */ new Set();
+      instance._currentRenderToken = void 0;
+    }
+  }
+}
+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)
+    );
+    if (process.env.NODE_ENV !== "production") {
+      const renderTime = Date.now() - renderStartTime;
+      if (renderTime > 5) {
+        logger.warn(
+          `[askr] Slow render detected: ${renderTime}ms. Consider optimizing component performance.`
+        );
+      }
+    }
+    if (!instance.firstRenderComplete) {
+      instance.firstRenderComplete = true;
+    }
+    if (process.env.NODE_ENV !== "production") {
+      for (let i = 0; i < instance.stateValues.length; i++) {
+        const state2 = instance.stateValues[i];
+        if (state2 && !state2._hasBeenRead) {
+          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 getSignal() {
+  if (!currentInstance) {
+    throw new Error(
+      "getSignal() can only be called during component render execution. Ensure you are calling this from inside your component function."
+    );
+  }
+  return currentInstance.abortController.signal;
+}
+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 getNextStateIndex() {
+  return stateIndex++;
+}
+function mountComponent(instance) {
+  executeComponent(instance);
+}
+function cleanupComponent(instance) {
+  for (const cleanup of instance.cleanupFns) {
+    cleanup();
+  }
+  instance.cleanupFns = [];
+  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();
+}
+var currentInstance, stateIndex, _globalRenderCounter;
+var init_component = __esm({
+  "src/runtime/component.ts"() {
+    "use strict";
+    init_dom();
+    init_scheduler();
+    init_context();
+    init_logger();
+    init_fastlane();
+    currentInstance = null;
+    stateIndex = 0;
+    _globalRenderCounter = 0;
+  }
+});
+
+// src/ssr/errors.ts
+var SSRDataMissingError;
+var init_errors = __esm({
+  "src/ssr/errors.ts"() {
+    "use strict";
+    SSRDataMissingError = class _SSRDataMissingError extends Error {
+      constructor(message = "Server-side rendering requires all data to be available synchronously. This component attempted to use async data during SSR.") {
+        super(message);
+        this.code = "SSR_DATA_MISSING";
+        this.name = "SSRDataMissingError";
+        Object.setPrototypeOf(this, _SSRDataMissingError.prototype);
+      }
+    };
+  }
+});
+
+// src/ssr/context.ts
+function withSSRContext(ctx, fn) {
+  const prev = current;
+  current = ctx;
+  try {
+    return fn();
+  } finally {
+    current = prev;
+  }
+}
+function createRenderContext(seed = 12345) {
+  const rng = new SeededRNG(seed);
+  return { seed, rng };
+}
+function getCurrentSSRContext() {
+  return currentSSRContext;
+}
+function runWithSSRContext(ctx, fn) {
+  const prev = currentSSRContext;
+  currentSSRContext = ctx;
+  try {
+    return fn();
+  } finally {
+    currentSSRContext = prev;
+  }
+}
+function throwSSRDataMissing() {
+  throw new SSRDataMissingError();
+}
+var current, SeededRNG, currentSSRContext;
+var init_context2 = __esm({
+  "src/ssr/context.ts"() {
+    "use strict";
+    init_errors();
+    current = null;
+    SeededRNG = class {
+      constructor(seed = 12345) {
+        this.seed = seed | 0;
+      }
+      reset(seed = 12345) {
+        this.seed = seed | 0;
+      }
+      // Simple LCG, stable and deterministic
+      random() {
+        this.seed = (this.seed * 9301 + 49297) % 233280;
+        return this.seed / 233280;
+      }
+    };
+    currentSSRContext = null;
+  }
+});
+
+// src/ssr/data.ts
+function getCurrentRenderData() {
+  return currentRenderData;
+}
+function resetKeyCounter() {
+  keyCounter = 0;
+}
+function getNextKey() {
+  return `r:${keyCounter++}`;
+}
+function startRenderPhase(data) {
+  currentRenderData = data ?? null;
+  resetKeyCounter();
+}
+function stopRenderPhase() {
+  currentRenderData = null;
+  resetKeyCounter();
+}
+async function resolvePlan(_plan) {
+  throw new Error(
+    "SSR resolution of prepass plans is removed: SSR is strictly synchronous and does not support resolving async resource plans"
+  );
+}
+function collectResources(_opts) {
+  throw new Error(
+    "SSR collection/prepass (collectResources) is removed: SSR is strictly synchronous and does not support prepass collection"
+  );
+}
+var keyCounter, currentRenderData, resolveResources;
+var init_data = __esm({
+  "src/ssr/data.ts"() {
+    "use strict";
+    keyCounter = 0;
+    currentRenderData = null;
+    resolveResources = resolvePlan;
+  }
+});
+
+// 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"() {
+    "use strict";
+  }
+});
+
+// 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 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 (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 createApp()."
+    );
+  }
+  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);
+  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();
+}
+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, routesByDepth, serverLocation, registrationLocked;
+var init_route = __esm({
+  "src/router/route.ts"() {
+    "use strict";
+    init_match();
+    init_component();
+    routes = [];
+    namespaces = /* @__PURE__ */ new Set();
+    routesByDepth = /* @__PURE__ */ new Map();
+    serverLocation = null;
+    registrationLocked = false;
+  }
+});
+
+// src/router/navigate.ts
+var navigate_exports = {};
+__export(navigate_exports, {
+  cleanupNavigation: () => cleanupNavigation,
+  initializeNavigation: () => initializeNavigation,
+  navigate: () => navigate,
+  registerAppInstance: () => registerAppInstance
+});
+function registerAppInstance(instance, _path) {
+  currentInstance2 = instance;
+  if (process.env.NODE_ENV === "production") {
+    lockRouteRegistration();
+  }
+}
+function navigate(path) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  const resolved = resolveRoute(path);
+  if (!resolved) {
+    if (process.env.NODE_ENV !== "production") {
+      logger.warn(`No route found for path: ${path}`);
+    }
+    return;
+  }
+  window.history.pushState({ path }, "", path);
+  if (currentInstance2) {
+    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 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);
+  }
+}
+function cleanupNavigation() {
+  if (typeof window !== "undefined") {
+    window.removeEventListener("popstate", handlePopState);
+  }
+}
+var currentInstance2;
+var init_navigate = __esm({
+  "src/router/navigate.ts"() {
+    "use strict";
+    init_route();
+    init_component();
+    init_logger();
+    currentInstance2 = null;
+  }
+});
+
+// src/ssr/sink.ts
+var StringSink, StreamSink;
+var init_sink = __esm({
+  "src/ssr/sink.ts"() {
+    "use strict";
+    StringSink = class {
+      constructor() {
+        this.chunks = [];
+      }
+      write(html) {
+        if (html) this.chunks.push(html);
+      }
+      end() {
+      }
+      toString() {
+        return this.chunks.join("");
+      }
+    };
+    StreamSink = class {
+      constructor(onChunk, onComplete) {
+        this.onChunk = onChunk;
+        this.onComplete = onComplete;
+      }
+      write(html) {
+        if (html) this.onChunk(html);
+      }
+      end() {
+        this.onComplete();
+      }
+    };
+  }
+});
+
+// src/ssr/render.ts
+function escapeText(text) {
+  const cached = escapeCache.get(text);
+  if (cached) return cached;
+  const str = String(text);
+  if (!str.includes("&") && !str.includes("<") && !str.includes(">")) {
+    if (escapeCache.size < 256) escapeCache.set(text, str);
+    return str;
+  }
+  const result = str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  if (escapeCache.size < 256) escapeCache.set(text, result);
+  return result;
+}
+function escapeAttr(value) {
+  const str = String(value);
+  if (!str.includes("&") && !str.includes('"') && !str.includes("'") && !str.includes("<") && !str.includes(">")) {
+    return str;
+  }
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function styleObjToCss(value) {
+  if (!value || typeof value !== "object") return null;
+  const entries = Object.entries(value);
+  if (entries.length === 0) return "";
+  let out = "";
+  for (const [k, v] of entries) {
+    if (v === null || v === void 0 || v === false) continue;
+    const prop = k.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+    out += `${prop}:${String(v)};`;
+  }
+  return out;
+}
+function renderAttrs(props) {
+  if (!props || typeof props !== "object") return "";
+  let result = "";
+  for (const [key, value] of Object.entries(props)) {
+    if (key === "children") continue;
+    if (key.startsWith("on") && key[2] === key[2]?.toUpperCase()) continue;
+    if (key.startsWith("_")) continue;
+    const attrName = key === "class" || key === "className" ? "class" : key;
+    if (attrName === "style") {
+      const css = typeof value === "string" ? value : styleObjToCss(value);
+      if (css === null) continue;
+      if (css === "") continue;
+      result += ` style="${escapeAttr(css)}"`;
+      continue;
+    }
+    if (value === true) {
+      result += ` ${attrName}`;
+    } else if (value === false || value === null || value === void 0) {
+      continue;
+    } else {
+      result += ` ${attrName}="${escapeAttr(String(value))}"`;
+    }
+  }
+  return result;
+}
+function isVNodeLike(x) {
+  return !!x && typeof x === "object" && "type" in x;
+}
+function normalizeChildren(node) {
+  const n = node;
+  const direct = Array.isArray(n?.children) ? n?.children : null;
+  const fromProps = n?.props?.children;
+  const raw = direct ?? fromProps;
+  if (raw === null || raw === void 0 || raw === false) return [];
+  if (Array.isArray(raw)) return raw;
+  return [raw];
+}
+function renderChildrenToSink(children, sink, ctx) {
+  for (const c of children)
+    renderNodeToSink(
+      c,
+      sink,
+      ctx
+    );
+}
+function executeComponent2(type, props, ctx) {
+  const res = type(props ?? {}, { signal: ctx.signal });
+  if (res && typeof res === "object" && "then" in res && typeof res.then === "function") {
+    throwSSRDataMissing();
+  }
+  return res;
+}
+function renderNodeToSink(node, sink, ctx) {
+  if (node === null || node === void 0) return;
+  if (typeof node === "string") {
+    sink.write(escapeText(node));
+    return;
+  }
+  if (typeof node === "number") {
+    sink.write(escapeText(String(node)));
+    return;
+  }
+  if (!isVNodeLike(node)) return;
+  const { type, props } = node;
+  if (typeof type === "function") {
+    const out = withSSRContext(
+      ctx,
+      () => executeComponent2(type, props, ctx)
+    );
+    renderNodeToSink(
+      out,
+      sink,
+      ctx
+    );
+    return;
+  }
+  const tag = String(type);
+  const attrs = renderAttrs(props);
+  if (VOID_ELEMENTS.has(tag)) {
+    sink.write(`<${tag}${attrs} />`);
+    return;
+  }
+  sink.write(`<${tag}${attrs}>`);
+  const children = normalizeChildren(node);
+  renderChildrenToSink(children, sink, ctx);
+  sink.write(`</${tag}>`);
+}
+var VOID_ELEMENTS, escapeCache;
+var init_render = __esm({
+  "src/ssr/render.ts"() {
+    "use strict";
+    init_context2();
+    VOID_ELEMENTS = /* @__PURE__ */ new Set([
+      "area",
+      "base",
+      "br",
+      "col",
+      "embed",
+      "hr",
+      "img",
+      "input",
+      "link",
+      "meta",
+      "param",
+      "source",
+      "track",
+      "wbr"
+    ]);
+    escapeCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/ssr/index.ts
+var ssr_exports = {};
+__export(ssr_exports, {
+  SSRDataMissingError: () => SSRDataMissingError,
+  collectResources: () => collectResources,
+  renderToStream: () => renderToStream,
+  renderToString: () => renderToString,
+  renderToStringSync: () => renderToStringSync,
+  renderToStringSyncForUrl: () => renderToStringSyncForUrl,
+  resolvePlan: () => resolvePlan,
+  resolveResources: () => resolveResources
+});
+function escapeText2(text) {
+  const cached = escapeCache2.get(text);
+  if (cached) return cached;
+  const str = String(text);
+  if (!str.includes("&") && !str.includes("<") && !str.includes(">")) {
+    escapeCache2.set(text, str);
+    return str;
+  }
+  const result = str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  if (escapeCache2.size < 256) {
+    escapeCache2.set(text, result);
+  }
+  return result;
+}
+function escapeAttr2(value) {
+  const str = String(value);
+  if (!str.includes("&") && !str.includes('"') && !str.includes("'") && !str.includes("<") && !str.includes(">")) {
+    return str;
+  }
+  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function renderAttrs2(props) {
+  if (!props || typeof props !== "object") return "";
+  let result = "";
+  for (const [key, value] of Object.entries(props)) {
+    if (key.startsWith("on") && key[2] === key[2].toUpperCase()) {
+      continue;
+    }
+    if (key.startsWith("_")) {
+      continue;
+    }
+    const attrName = key === "class" || key === "className" ? "class" : key;
+    if (value === true) {
+      result += ` ${attrName}`;
+    } else if (value === false || value === null || value === void 0) {
+      continue;
+    } else {
+      result += ` ${attrName}="${escapeAttr2(String(value))}"`;
+    }
+  }
+  return result;
+}
+function renderChildSync(child, ctx) {
+  if (typeof child === "string") return escapeText2(child);
+  if (typeof child === "number") return escapeText2(String(child));
+  if (child === null || child === void 0 || child === false) return "";
+  if (typeof child === "object" && child !== null && "type" in child) {
+    return renderNodeSync(child, ctx);
+  }
+  return "";
+}
+function renderChildrenSync(children, ctx) {
+  if (!children || !Array.isArray(children) || children.length === 0) return "";
+  let result = "";
+  for (const child of children) result += renderChildSync(child, ctx);
+  return result;
+}
+function renderNodeSync(node, ctx) {
+  const { type, props } = node;
+  if (typeof type === "function") {
+    const result = executeComponentSync2(type, props, ctx);
+    if (result instanceof Promise) {
+      throwSSRDataMissing();
+    }
+    return renderNodeSync(result, ctx);
+  }
+  const typeStr = type;
+  if (VOID_ELEMENTS2.has(typeStr)) {
+    const attrs2 = renderAttrs2(props);
+    return `<${typeStr}${attrs2} />`;
+  }
+  const attrs = renderAttrs2(props);
+  const children = node.children;
+  const childrenHtml = renderChildrenSync(children, ctx);
+  return `<${typeStr}${attrs}>${childrenHtml}</${typeStr}>`;
+}
+function executeComponentSync2(component, props, ctx) {
+  const originalRandom = Math.random;
+  const originalDateNow = Date.now;
+  try {
+    if (process.env.NODE_ENV !== "production") {
+      Math.random = () => {
+        throw new Error(
+          "SSR Strict Purity: Math.random is not allowed during synchronous SSR. Use the provided `ssr` context RNG instead."
+        );
+      };
+      Date.now = () => {
+        throw new Error(
+          "SSR Strict Purity: Date.now is not allowed during synchronous SSR. Pass timestamps explicitly or use deterministic helpers."
+        );
+      };
+    }
+    const prev = getCurrentComponentInstance();
+    const temp = createComponentInstance(
+      "ssr-temp",
+      component,
+      props || {},
+      null
+    );
+    temp.ssr = true;
+    setCurrentComponentInstance(temp);
+    try {
+      return runWithSSRContext(ctx, () => {
+        const result = component(props || {}, { ssr: ctx });
+        if (result instanceof Promise) {
+          throwSSRDataMissing();
+        }
+        return result;
+      });
+    } finally {
+      setCurrentComponentInstance(prev);
+    }
+  } finally {
+    Math.random = originalRandom;
+    Date.now = originalDateNow;
+  }
+}
+function renderToStringSync(component, props, options) {
+  const seed = options?.seed ?? 12345;
+  const ctx = createRenderContext(seed);
+  startRenderPhase(options?.data ?? null);
+  try {
+    const node = executeComponentSync2(component, props || {}, ctx);
+    return renderNodeSync(node, ctx);
+  } finally {
+    stopRenderPhase();
+  }
+}
+function renderToStringSyncForUrl(opts) {
+  const { url, routes: routes2, options } = opts;
+  const {
+    clearRoutes: clearRoutes2,
+    route: route2,
+    setServerLocation: setServerLocation2,
+    lockRouteRegistration: lockRouteRegistration2,
+    resolveRoute: resolveRoute2
+  } = route_exports;
+  clearRoutes2();
+  for (const r of routes2) {
+    route2(r.path, r.handler, r.namespace);
+  }
+  setServerLocation2(url);
+  if (process.env.NODE_ENV === "production") lockRouteRegistration2();
+  const resolved = resolveRoute2(url);
+  if (!resolved)
+    throw new Error(`renderToStringSync: no route found for url: ${url}`);
+  const seed = options?.seed ?? 12345;
+  const ctx = createRenderContext(seed);
+  startRenderPhase(options?.data ?? null);
+  try {
+    const node = executeComponentSync2(
+      resolved.handler,
+      resolved.params || {},
+      ctx
+    );
+    return renderNodeSync(node, ctx);
+  } finally {
+    stopRenderPhase();
+  }
+}
+function renderToString(arg) {
+  if (typeof arg === "function") {
+    return renderToStringSync(
+      arg
+    );
+  }
+  const opts = arg;
+  const sink = new StringSink();
+  renderToSinkInternal({ ...opts, sink });
+  sink.end();
+  return sink.toString();
+}
+function renderToStream(opts) {
+  const sink = new StreamSink(opts.onChunk, opts.onComplete);
+  renderToSinkInternal({ ...opts, sink });
+  sink.end();
+}
+function renderToSinkInternal(opts) {
+  const { url, routes: routes2, seed = 1, data, sink } = opts;
+  const {
+    clearRoutes: clearRoutes2,
+    route: route2,
+    setServerLocation: setServerLocation2,
+    lockRouteRegistration: lockRouteRegistration2,
+    resolveRoute: resolveRoute2
+  } = route_exports;
+  clearRoutes2();
+  for (const r of routes2) route2(r.path, r.handler, r.namespace);
+  setServerLocation2(url);
+  if (process.env.NODE_ENV === "production") lockRouteRegistration2();
+  const resolved = resolveRoute2(url);
+  if (!resolved) throw new Error(`SSR: no route found for url: ${url}`);
+  const ctx = {
+    url,
+    seed,
+    data,
+    params: resolved.params,
+    signal: void 0
+  };
+  const node = resolved.handler(resolved.params);
+  startRenderPhase(data || null);
+  try {
+    renderNodeToSink(node, sink, ctx);
+  } finally {
+    stopRenderPhase();
+  }
+}
+var VOID_ELEMENTS2, escapeCache2;
+var init_ssr = __esm({
+  "src/ssr/index.ts"() {
+    "use strict";
+    init_route();
+    init_context2();
+    init_component();
+    init_context2();
+    init_sink();
+    init_render();
+    init_data();
+    VOID_ELEMENTS2 = /* @__PURE__ */ new Set([
+      "area",
+      "base",
+      "br",
+      "col",
+      "embed",
+      "hr",
+      "img",
+      "input",
+      "link",
+      "meta",
+      "param",
+      "source",
+      "track",
+      "wbr"
+    ]);
+    escapeCache2 = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Fragment: () => Fragment,
+  Link: () => Link,
+  cleanupApp: () => cleanupApp,
+  clearRoutes: () => clearRoutes,
+  collectResources: () => collectResources,
+  createApp: () => createApp,
+  createIsland: () => createIsland,
+  createSPA: () => createSPA,
+  defineContext: () => defineContext,
+  getLoadedNamespaces: () => getLoadedNamespaces,
+  getNamespaceRoutes: () => getNamespaceRoutes,
+  getRoutes: () => getRoutes,
+  getSignal: () => getSignal,
+  hasApp: () => hasApp,
+  hydrateSPA: () => hydrateSPA,
+  jsx: () => jsx,
+  jsxs: () => jsxs,
+  layout: () => layout,
+  navigate: () => navigate,
+  readContext: () => readContext,
+  renderToStream: () => renderToStream,
+  renderToString: () => renderToString,
+  renderToStringSync: () => renderToStringSync,
+  renderToStringSyncForUrl: () => renderToStringSyncForUrl,
+  resolveResources: () => resolveResources,
+  resource: () => resource,
+  route: () => route,
+  scheduleEventHandler: () => scheduleEventHandler,
+  setServerLocation: () => setServerLocation,
+  state: () => state,
+  unloadNamespace: () => unloadNamespace
+});
+module.exports = __toCommonJS(index_exports);
+
+// 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 = (newValue) => {
+    const currentInst = getCurrentInstance();
+    if (currentInst !== null && process.env.NODE_ENV !== "production") {
+      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.`
+      );
+    }
+    if (currentInst !== null && process.env.NODE_ENV === "production") {
+      return;
+    }
+    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/index.ts
+init_component();
+init_scheduler();
+init_context();
+
+// src/runtime/operations.ts
+init_component();
+init_context();
+
+// src/runtime/resource_cell.ts
+init_context();
+init_logger();
+init_context2();
+var ResourceCell = class {
+  constructor(fn, deps, resourceFrame) {
+    this.value = null;
+    this.pending = true;
+    this.error = null;
+    this.generation = 0;
+    this.controller = null;
+    this.deps = null;
+    this.resourceFrame = null;
+    this.subscribers = /* @__PURE__ */ new Set();
+    this.fn = fn;
+    this.deps = deps ? deps.slice() : null;
+    this.resourceFrame = resourceFrame;
+    this.snapshot = {
+      value: null,
+      pending: true,
+      error: null,
+      refresh: () => this.refresh()
+    };
+  }
+  subscribe(cb) {
+    this.subscribers.add(cb);
+    return () => this.subscribers.delete(cb);
+  }
+  notifySubscribers() {
+    this.snapshot.value = this.value;
+    this.snapshot.pending = this.pending;
+    this.snapshot.error = this.error;
+    for (const cb of this.subscribers) cb();
+  }
+  start(ssr = false, notify = true) {
+    const generation = this.generation;
+    this.controller?.abort();
+    const controller = new AbortController();
+    this.controller = controller;
+    this.pending = true;
+    this.error = null;
+    if (notify) this.notifySubscribers();
+    let result;
+    try {
+      result = withAsyncResourceContext(
+        this.resourceFrame,
+        () => this.fn({ signal: controller.signal })
+      );
+    } catch (err) {
+      this.pending = false;
+      this.error = err;
+      if (notify) this.notifySubscribers();
+      return;
+    }
+    if (!(result instanceof Promise)) {
+      this.value = result;
+      this.pending = false;
+      this.error = null;
+      if (notify) this.notifySubscribers();
+      return;
+    }
+    if (ssr) {
+      throwSSRDataMissing();
+    }
+    result.then((val) => {
+      if (this.generation !== generation) return;
+      if (this.controller !== controller) return;
+      this.value = val;
+      this.pending = false;
+      this.error = null;
+      this.notifySubscribers();
+    }).catch((err) => {
+      if (this.generation !== generation) return;
+      this.pending = false;
+      this.error = err;
+      try {
+        logger.error("[Askr] Async resource error:", err);
+      } catch {
+      }
+      this.notifySubscribers();
+    });
+  }
+  refresh() {
+    this.generation++;
+    this.controller?.abort();
+    this.start();
+  }
+  abort() {
+    this.controller?.abort();
+  }
+};
+
+// src/runtime/operations.ts
+init_context2();
+init_data();
+function resource(fn, deps = []) {
+  const instance = getCurrentComponentInstance();
+  const inst = instance;
+  if (!instance) {
+    const renderData2 = getCurrentRenderData();
+    if (renderData2) {
+      const key = getNextKey();
+      if (!(key in renderData2)) {
+        throwSSRDataMissing();
+      }
+      const val = renderData2[key];
+      return {
+        value: val,
+        pending: false,
+        error: null,
+        refresh: () => {
+        }
+      };
+    }
+    const ssrCtx = getCurrentSSRContext();
+    if (ssrCtx) {
+      throwSSRDataMissing();
+    }
+    return {
+      value: null,
+      pending: true,
+      error: null,
+      refresh: () => {
+      }
+    };
+  }
+  const renderData = getCurrentRenderData();
+  if (renderData) {
+    const key = getNextKey();
+    if (!(key in renderData)) {
+      throwSSRDataMissing();
+    }
+    const val = renderData[key];
+    const holder2 = state({
+      cell: void 0,
+      snapshot: {
+        value: val,
+        pending: false,
+        error: null,
+        refresh: () => {
+        }
+      }
+    });
+    const h2 = holder2();
+    h2.snapshot.value = val;
+    h2.snapshot.pending = false;
+    h2.snapshot.error = null;
+    holder2.set(h2);
+    return h2.snapshot;
+  }
+  const holder = state({
+    cell: void 0,
+    snapshot: {
+      value: null,
+      pending: true,
+      error: null,
+      refresh: () => {
+      }
+    }
+  });
+  const h = holder();
+  if (!h.cell) {
+    const frame = getCurrentContextFrame();
+    const cell2 = new ResourceCell(fn, deps, frame);
+    h.cell = cell2;
+    h.snapshot = cell2.snapshot;
+    const unsubscribe = cell2.subscribe(() => {
+      const cur = holder();
+      cur.snapshot.value = cell2.snapshot.value;
+      cur.snapshot.pending = cell2.snapshot.pending;
+      cur.snapshot.error = cell2.snapshot.error;
+      holder.set(cur);
+      try {
+        inst._enqueueRun?.();
+      } catch {
+      }
+    });
+    inst.cleanupFns.push(() => {
+      unsubscribe();
+      cell2.abort();
+    });
+    try {
+      cell2.start(inst.ssr ?? false, false);
+      if (!cell2.pending) {
+        const cur = holder();
+        cur.snapshot.value = cell2.value;
+        cur.snapshot.pending = cell2.pending;
+        cur.snapshot.error = cell2.error;
+      }
+    } catch (err) {
+      if (err instanceof SSRDataMissingError) throw err;
+      cell2.error = err;
+      cell2.pending = false;
+      const cur = holder();
+      cur.snapshot.value = cell2.value;
+      cur.snapshot.pending = cell2.pending;
+      cur.snapshot.error = cell2.error;
+    }
+  }
+  const cell = h.cell;
+  const depsChanged = !cell.deps || cell.deps.length !== deps.length || cell.deps.some((d, i) => d !== deps[i]);
+  if (depsChanged) {
+    cell.deps = deps.slice();
+    cell.generation++;
+    cell.pending = true;
+    cell.error = null;
+    try {
+      cell.start(inst.ssr ?? false, false);
+      if (!cell.pending) {
+        const cur = holder();
+        cur.snapshot.value = cell.value;
+        cur.snapshot.pending = cell.pending;
+        cur.snapshot.error = cell.error;
+      }
+    } catch (err) {
+      if (err instanceof SSRDataMissingError) throw err;
+      cell.error = err;
+      cell.pending = false;
+      const cur = holder();
+      cur.snapshot.value = cell.value;
+      cur.snapshot.pending = cell.pending;
+      cur.snapshot.error = cell.error;
+    }
+  }
+  return h.snapshot;
+}
+
+// src/app/createApp.ts
+init_component();
+init_scheduler();
+init_logger();
+init_dom();
+init_navigate();
+var componentIdCounter = 0;
+var instancesByRoot = /* @__PURE__ */ new WeakMap();
+var CLEANUP_SYMBOL = /* @__PURE__ */ Symbol.for("__tempoCleanup__");
+function createApp(config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("createApp requires a config object");
+  }
+  if ("routes" in config) {
+    throw new Error(
+      "The `createApp` API is removed. Use `createSPA({ root, routes })` for routed apps, or `hydrateSPA({ root, routes })` for SSR hydration."
+    );
+  }
+  const appCfg = config;
+  createIsland({
+    root: appCfg.root,
+    component: appCfg.component
+  });
+}
+function attachCleanupForRoot(rootElement, instance) {
+  rootElement[CLEANUP_SYMBOL] = () => {
+    removeAllListeners(rootElement);
+    cleanupComponent(instance);
+  };
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(rootElement, "innerHTML") || Object.getOwnPropertyDescriptor(
+      Object.getPrototypeOf(rootElement),
+      "innerHTML"
+    ) || Object.getOwnPropertyDescriptor(Element.prototype, "innerHTML");
+    if (descriptor && (descriptor.get || descriptor.set)) {
+      Object.defineProperty(rootElement, "innerHTML", {
+        get: descriptor.get ? function() {
+          return descriptor.get.call(this);
+        } : void 0,
+        set: function(value) {
+          if (value === "" && instancesByRoot.get(this) === instance) {
+            removeAllListeners(rootElement);
+            cleanupComponent(instance);
+          }
+          if (descriptor.set) {
+            return descriptor.set.call(this, value);
+          }
+        },
+        configurable: true
+      });
+    }
+  } catch {
+  }
+}
+function mountOrUpdate(rootElement, componentFn) {
+  const existingCleanup = rootElement[CLEANUP_SYMBOL];
+  if (existingCleanup) existingCleanup();
+  let instance = instancesByRoot.get(rootElement);
+  if (instance) {
+    removeAllListeners(rootElement);
+    cleanupComponent(instance);
+    instance.fn = componentFn;
+    instance.evaluationGeneration++;
+    instance.mounted = false;
+    instance.expectedStateIndices = [];
+    instance.firstRenderComplete = false;
+    instance.isRoot = true;
+  } else {
+    const componentId = String(++componentIdCounter);
+    instance = createComponentInstance(
+      componentId,
+      componentFn,
+      {},
+      rootElement
+    );
+    instancesByRoot.set(rootElement, instance);
+    instance.isRoot = true;
+  }
+  attachCleanupForRoot(rootElement, instance);
+  mountComponent(instance);
+  globalScheduler.flush();
+}
+function createIsland(config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("createIsland requires a config object");
+  }
+  if (typeof config.component !== "function") {
+    throw new Error("createIsland: component must be a function");
+  }
+  const rootElement = typeof config.root === "string" ? document.getElementById(config.root) : config.root;
+  if (!rootElement) throw new Error(`Root element not found: ${config.root}`);
+  if ("routes" in config) {
+    throw new Error(
+      "createIsland does not accept routes; use createSPA for routed apps"
+    );
+  }
+  mountOrUpdate(rootElement, config.component);
+}
+async function createSPA(config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("createSPA requires a config object");
+  }
+  if (!Array.isArray(config.routes) || config.routes.length === 0) {
+    throw new Error(
+      "createSPA requires a route table. If you are enhancing existing HTML, use createIsland instead."
+    );
+  }
+  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: clearRoutes2, route: route2, lockRouteRegistration: lockRouteRegistration2, resolveRoute: resolveRoute2 } = await Promise.resolve().then(() => (init_route(), route_exports));
+  clearRoutes2();
+  for (const r of config.routes) {
+    route2(r.path, r.handler, r.namespace);
+  }
+  if (process.env.NODE_ENV === "production") lockRouteRegistration2();
+  const path = typeof window !== "undefined" ? window.location.pathname : "/";
+  const resolved = resolveRoute2(path);
+  if (!resolved) {
+    if (process.env.NODE_ENV !== "production") {
+      logger.warn(
+        `createSPA: no route found for current path (${path}). Mounting empty placeholder; navigation will activate routes when requested.`
+      );
+    }
+    mountOrUpdate(rootElement, () => ({ type: "div", children: [] }));
+    const instance2 = instancesByRoot.get(rootElement);
+    if (!instance2) throw new Error("Internal error: app instance missing");
+    registerAppInstance(instance2, path);
+    initializeNavigation();
+    return;
+  }
+  mountOrUpdate(rootElement, resolved.handler);
+  const instance = instancesByRoot.get(rootElement);
+  if (!instance) throw new Error("Internal error: app instance missing");
+  registerAppInstance(instance, path);
+  initializeNavigation();
+}
+async function hydrateSPA(config) {
+  if (!config || typeof config !== "object") {
+    throw new Error("hydrateSPA requires a config object");
+  }
+  if (!Array.isArray(config.routes) || config.routes.length === 0) {
+    throw new Error(
+      "hydrateSPA requires a route table. If you are enhancing existing HTML, use createIsland instead."
+    );
+  }
+  const rootElement = typeof config.root === "string" ? document.getElementById(config.root) : config.root;
+  if (!rootElement) throw new Error(`Root element not found: ${config.root}`);
+  const serverHTML = rootElement.innerHTML;
+  const {
+    clearRoutes: clearRoutes2,
+    route: route2,
+    setServerLocation: setServerLocation2,
+    lockRouteRegistration: lockRouteRegistration2,
+    resolveRoute: resolveRoute2
+  } = await Promise.resolve().then(() => (init_route(), route_exports));
+  clearRoutes2();
+  for (const r of config.routes) {
+    route2(r.path, r.handler, r.namespace);
+  }
+  const path = typeof window !== "undefined" ? window.location.pathname : "/";
+  setServerLocation2(path);
+  if (process.env.NODE_ENV === "production") lockRouteRegistration2();
+  const resolved = resolveRoute2(path);
+  if (!resolved) {
+    throw new Error(`hydrateSPA: no route found for current path (${path}).`);
+  }
+  const { renderToStringSync: renderToStringSync2 } = await Promise.resolve().then(() => (init_ssr(), ssr_exports));
+  const expectedHTML = renderToStringSync2(() => {
+    const out = resolved.handler(resolved.params);
+    return out ?? {
+      type: "div",
+      children: []
+    };
+  });
+  const serverContainer = document.createElement("div");
+  serverContainer.innerHTML = serverHTML;
+  const expectedContainer = document.createElement("div");
+  expectedContainer.innerHTML = expectedHTML;
+  if (!serverContainer.isEqualNode(expectedContainer)) {
+    throw new Error(
+      "[Askr] Hydration mismatch detected. Server HTML does not match expected server-render output."
+    );
+  }
+  mountOrUpdate(rootElement, resolved.handler);
+  const { registerAppInstance: registerAppInstance2, initializeNavigation: initializeNavigation2 } = await Promise.resolve().then(() => (init_navigate(), navigate_exports));
+  const instance = instancesByRoot.get(rootElement);
+  if (!instance) throw new Error("Internal error: app instance missing");
+  registerAppInstance2(instance, path);
+  initializeNavigation2();
+}
+function cleanupApp(root) {
+  const rootElement = typeof root === "string" ? document.getElementById(root) : root;
+  if (!rootElement) return;
+  const cleanupFn = rootElement[CLEANUP_SYMBOL];
+  if (typeof cleanupFn === "function") {
+    cleanupFn();
+  }
+  instancesByRoot.delete(rootElement);
+}
+function hasApp(root) {
+  const rootElement = typeof root === "string" ? document.getElementById(root) : root;
+  if (!rootElement) return false;
+  return instancesByRoot.has(rootElement);
+}
+
+// src/index.ts
+init_route();
+
+// src/router/layouts.ts
+function layout(Layout) {
+  return (children) => Layout({ children });
+}
+
+// src/index.ts
+init_route();
+init_navigate();
+
+// src/components/Link.tsx
+init_navigate();
+function Link({ href, children }) {
+  return {
+    type: "a",
+    props: {
+      href,
+      children,
+      onClick: (e) => {
+        const event = e;
+        const button = event.button ?? 0;
+        if (button !== 0 || // not left-click
+        event.ctrlKey || // Ctrl/Cmd+click
+        event.metaKey || // Cmd on Mac
+        event.shiftKey || // Shift+click
+        event.altKey) {
+          return;
+        }
+        event.preventDefault();
+        navigate(href);
+      }
+    }
+  };
+}
+
+// src/index.ts
+init_ssr();
+init_jsx_runtime();
+init_route();
+init_navigate();
+if (typeof globalThis !== "undefined") {
+  const g = globalThis;
+  if (!g.createApp) g.createApp = createApp;
+  if (!g.createIsland) g.createIsland = createIsland;
+  if (!g.createSPA) g.createSPA = createSPA;
+  if (!g.hydrateSPA) g.hydrateSPA = hydrateSPA;
+  if (!g.route) g.route = route;
+  if (!g.getRoutes) g.getRoutes = getRoutes;
+  if (!g.navigate) g.navigate = navigate;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Fragment,
+  Link,
+  cleanupApp,
+  clearRoutes,
+  collectResources,
+  createApp,
+  createIsland,
+  createSPA,
+  defineContext,
+  getLoadedNamespaces,
+  getNamespaceRoutes,
+  getRoutes,
+  getSignal,
+  hasApp,
+  hydrateSPA,
+  jsx,
+  jsxs,
+  layout,
+  navigate,
+  readContext,
+  renderToStream,
+  renderToString,
+  renderToStringSync,
+  renderToStringSyncForUrl,
+  resolveResources,
+  resource,
+  route,
+  scheduleEventHandler,
+  setServerLocation,
+  state,
+  unloadNamespace
+});
+//# sourceMappingURL=index.cjs.map