@askrjs/askr 0.0.3 → 0.0.4

package/dist/index.cjs

@@ -85,36 +85,11 @@ function isBulkCommitActive() {
 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() {
@@ -136,9 +111,9 @@ var init_scheduler = __esm({
         // Keep a lightweight taskCount for compatibility/diagnostics
         this.taskCount = 0;
       }
-      enqueue(task2) {
+      enqueue(task) {
         assertSchedulingPrecondition(
-          typeof task2 === "function",
+          typeof task === "function",
           "enqueue() requires a function"
         );
         if (isBulkCommitActive() && !this.allowSyncProgress) {
@@ -149,7 +124,7 @@ var init_scheduler = __esm({
           }
           return;
         }
-        this.q.push(task2);
+        this.q.push(task);
         this.taskCount++;
         if (!this.running && !this.kickScheduled && !this.inHandler && !isBulkCommitActive()) {
           this.kickScheduled = true;
@@ -190,10 +165,10 @@ var init_scheduler = __esm({
                 `[Scheduler] exceeded MAX_FLUSH_DEPTH (${MAX_FLUSH_DEPTH}). Likely infinite update loop.`
               );
             }
-            const task2 = this.q[this.head++];
+            const task = this.q[this.head++];
             try {
               this.executionDepth++;
-              task2();
+              task();
               this.executionDepth--;
             } catch (err) {
               if (this.executionDepth > 0) this.executionDepth = 0;
@@ -211,14 +186,10 @@ var init_scheduler = __esm({
             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;
+            for (let i = 0; i < remaining; i++) {
+              this.q[i] = this.q[this.head + i];
             }
+            this.q.length = remaining;
             this.head = 0;
           }
           this.flushVersion++;
@@ -373,123 +344,15 @@ function withContext(frame, fn) {
     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) => {
-      const value = props.value;
-      return {
-        type: ContextScopeComponent,
-        props: { key, 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]])
-  };
-  function createFunctionChildInvoker(fn, frame, owner) {
-    return {
-      type: ContextFunctionChildInvoker,
-      props: { fn, __frame: frame, __owner: owner }
-    };
-  }
-  if (Array.isArray(children)) {
-    return children.map((child) => {
-      if (typeof child === "function") {
-        return createFunctionChildInvoker(
-          child,
-          newFrame,
-          getCurrentComponentInstance()
-        );
-      }
-      return markWithFrame(child, newFrame);
-    });
-  } else if (typeof children === "function") {
-    return createFunctionChildInvoker(
-      children,
-      newFrame,
-      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 CONTEXT_FRAME_SYMBOL, currentContextFrame;
 var init_context = __esm({
   "src/runtime/context.ts"() {
     "use strict";
-    init_component();
     CONTEXT_FRAME_SYMBOL = /* @__PURE__ */ Symbol("__tempoContextFrame__");
     currentContextFrame = null;
-    currentAsyncResourceFrame = null;
   }
 });
 
@@ -555,172 +418,6 @@ var init_diag = __esm({
   }
 });
 
-// src/runtime/dev-namespace.ts
-function getDevNamespace() {
-  if (process.env.NODE_ENV === "production") return {};
-  try {
-    const g = globalThis;
-    if (!g.__ASKR__) g.__ASKR__ = {};
-    return g.__ASKR__;
-  } catch {
-    return {};
-  }
-}
-function setDevValue(key, value) {
-  if (process.env.NODE_ENV === "production") return;
-  try {
-    getDevNamespace()[key] = value;
-  } catch {
-  }
-}
-function getDevValue(key) {
-  if (process.env.NODE_ENV === "production") return void 0;
-  try {
-    return getDevNamespace()[key];
-  } catch {
-    return void 0;
-  }
-}
-var init_dev_namespace = __esm({
-  "src/runtime/dev-namespace.ts"() {
-    "use strict";
-  }
-});
-
-// src/runtime/fastlane-shared.ts
-function enterBulkCommit() {
-  _bulkCommitActive = true;
-  _appliedParents = /* @__PURE__ */ new WeakSet();
-  try {
-    const cleared = globalScheduler.clearPendingSyncTasks?.() ?? 0;
-    setDevValue("__ASKR_FASTLANE_CLEARED_TASKS", cleared);
-  } catch (err) {
-    if (process.env.NODE_ENV !== "production") throw err;
-  }
-}
-function exitBulkCommit() {
-  _bulkCommitActive = false;
-  _appliedParents = null;
-}
-function isBulkCommitActive2() {
-  return _bulkCommitActive;
-}
-function markFastPathApplied(parent) {
-  if (!_appliedParents) return;
-  try {
-    _appliedParents.add(parent);
-  } catch (e) {
-    void e;
-  }
-}
-function isFastPathApplied(parent) {
-  return !!(_appliedParents && _appliedParents.has(parent));
-}
-var _bulkCommitActive, _appliedParents;
-var init_fastlane_shared = __esm({
-  "src/runtime/fastlane-shared.ts"() {
-    "use strict";
-    init_scheduler();
-    init_dev_namespace();
-    _bulkCommitActive = false;
-    _appliedParents = null;
-  }
-});
-
-// src/renderer/types.ts
-function _isDOMElement(node) {
-  return typeof node === "object" && node !== null && "type" in node;
-}
-var init_types = __esm({
-  "src/renderer/types.ts"() {
-    "use strict";
-  }
-});
-
-// src/renderer/cleanup.ts
-function cleanupSingleInstance(node, errors, strict) {
-  const inst = node.__ASKR_INSTANCE;
-  if (!inst) return;
-  try {
-    cleanupComponent(inst);
-  } catch (err) {
-    if (strict) errors.push(err);
-    else logger.warn("[Askr] cleanupComponent failed:", err);
-  }
-  try {
-    delete node.__ASKR_INSTANCE;
-  } catch (e) {
-    if (strict) errors.push(e);
-  }
-}
-function cleanupInstanceIfPresent(node, opts) {
-  if (!node || !(node instanceof Element)) return;
-  const errors = [];
-  const strict = opts?.strict ?? false;
-  try {
-    cleanupSingleInstance(node, errors, strict);
-  } catch (err) {
-    if (strict) errors.push(err);
-    else logger.warn("[Askr] cleanupInstanceIfPresent failed:", err);
-  }
-  try {
-    const descendants = node.querySelectorAll("*");
-    for (const d of Array.from(descendants)) {
-      try {
-        cleanupSingleInstance(d, errors, strict);
-      } catch (err) {
-        if (strict) errors.push(err);
-        else
-          logger.warn(
-            "[Askr] cleanupInstanceIfPresent descendant cleanup failed:",
-            err
-          );
-      }
-    }
-  } catch (err) {
-    if (strict) errors.push(err);
-    else
-      logger.warn(
-        "[Askr] cleanupInstanceIfPresent descendant query failed:",
-        err
-      );
-  }
-  if (errors.length > 0) {
-    throw new AggregateError(errors, "cleanupInstanceIfPresent failed");
-  }
-}
-function cleanupInstancesUnder(node, opts) {
-  cleanupInstanceIfPresent(node, opts);
-}
-function removeElementListeners(element) {
-  const map = elementListeners.get(element);
-  if (map) {
-    for (const [eventName, entry] of map) {
-      if (entry.options !== void 0)
-        element.removeEventListener(eventName, entry.handler, entry.options);
-      else element.removeEventListener(eventName, entry.handler);
-    }
-    elementListeners.delete(element);
-  }
-}
-function removeAllListeners(root) {
-  if (!root) return;
-  removeElementListeners(root);
-  const children = root.querySelectorAll("*");
-  for (let i = 0; i < children.length; i++) {
-    removeElementListeners(children[i]);
-  }
-}
-var elementListeners;
-var init_cleanup = __esm({
-  "src/renderer/cleanup.ts"() {
-    "use strict";
-    init_component();
-    init_logger();
-    elementListeners = /* @__PURE__ */ new WeakMap();
-  }
-});
-
 // src/renderer/utils.ts
 function parseEventName(propName) {
   if (!propName.startsWith("on") || propName.length <= 2) return null;
@@ -809,8 +506,7 @@ function extractKey(vnode) {
 }
 function buildKeyMapFromChildren(parent) {
   const map = /* @__PURE__ */ new Map();
-  const children = Array.from(parent.children);
-  for (const ch of children) {
+  for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {
     const k = ch.getAttribute("data-key");
     if (k !== null) {
       map.set(k, ch);
@@ -985,269 +681,668 @@ var init_keyed = __esm({
   }
 });
 
-// src/jsx/types.ts
+// src/common/jsx.ts
 var ELEMENT_TYPE, Fragment;
-var init_types2 = __esm({
-  "src/jsx/types.ts"() {
+var init_jsx = __esm({
+  "src/common/jsx.ts"() {
     "use strict";
     ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("askr.element");
     Fragment = /* @__PURE__ */ Symbol.for("askr.fragment");
   }
 });
 
-// src/jsx/jsx-runtime.ts
-function jsxDEV(type, props, key) {
-  return {
-    $$typeof: ELEMENT_TYPE2,
-    type,
-    props: props ?? {},
-    key: key ?? null
-  };
+// src/runtime/dev-namespace.ts
+function getDevNamespace() {
+  if (process.env.NODE_ENV === "production") return {};
+  try {
+    const g = globalThis;
+    if (!g.__ASKR__) g.__ASKR__ = {};
+    return g.__ASKR__;
+  } catch {
+    return {};
+  }
 }
-function jsx(type, props, key) {
-  return jsxDEV(type, props, key);
+function setDevValue(key, value) {
+  if (process.env.NODE_ENV === "production") return;
+  try {
+    getDevNamespace()[key] = value;
+  } catch {
+  }
 }
-function jsxs(type, props, key) {
-  return jsxDEV(type, props, key);
+function getDevValue(key) {
+  if (process.env.NODE_ENV === "production") return void 0;
+  try {
+    return getDevNamespace()[key];
+  } catch {
+    return void 0;
+  }
 }
-var ELEMENT_TYPE2, Fragment2;
-var init_jsx_runtime = __esm({
-  "src/jsx/jsx-runtime.ts"() {
+var init_dev_namespace = __esm({
+  "src/runtime/dev-namespace.ts"() {
     "use strict";
-    init_types2();
-    ELEMENT_TYPE2 = /* @__PURE__ */ Symbol.for("askr.element");
-    Fragment2 = /* @__PURE__ */ Symbol.for("askr.fragment");
   }
 });
 
-// src/renderer/dom.ts
-function addTrackedListener(el, eventName, handler) {
-  const wrappedHandler = createWrappedHandler(handler, true);
-  const options = getPassiveOptions(eventName);
-  if (options !== void 0) {
-    el.addEventListener(eventName, wrappedHandler, options);
-  } else {
-    el.addEventListener(eventName, wrappedHandler);
+// src/runtime/fastlane.ts
+function enterBulkCommit() {
+  _bulkCommitActive = true;
+  _appliedParents = /* @__PURE__ */ new WeakSet();
+  try {
+    const cleared = globalScheduler.clearPendingSyncTasks?.() ?? 0;
+    setDevValue("__ASKR_FASTLANE_CLEARED_TASKS", cleared);
+  } catch (err) {
+    if (process.env.NODE_ENV !== "production") throw err;
   }
-  if (!elementListeners.has(el)) {
-    elementListeners.set(el, /* @__PURE__ */ new Map());
+}
+function exitBulkCommit() {
+  _bulkCommitActive = false;
+  _appliedParents = null;
+}
+function isBulkCommitActive2() {
+  return _bulkCommitActive;
+}
+function markFastPathApplied(parent) {
+  if (!_appliedParents) return;
+  try {
+    _appliedParents.add(parent);
+  } catch (e) {
+    void e;
   }
-  elementListeners.get(el).set(eventName, {
-    handler: wrappedHandler,
-    original: handler,
-    options
-  });
 }
-function applyPropsToElement(el, props, tagName) {
-  for (const key in props) {
-    const value = props[key];
-    if (isSkippedProp(key)) continue;
-    if (value === void 0 || value === null || value === false) continue;
-    const eventName = parseEventName(key);
-    if (eventName) {
-      addTrackedListener(el, eventName, value);
-      continue;
+function isFastPathApplied(parent) {
+  return !!(_appliedParents && _appliedParents.has(parent));
+}
+function finalizeReadSubscriptions(instance) {
+  const newSet = instance._pendingReadStates ?? /* @__PURE__ */ new Set();
+  const oldSet = instance._lastReadStates ?? /* @__PURE__ */ new Set();
+  const token = instance._currentRenderToken;
+  if (token === void 0) return;
+  for (const s of oldSet) {
+    if (!newSet.has(s)) {
+      const readers = s._readers;
+      if (readers) readers.delete(instance);
     }
-    if (key === "class" || key === "className") {
-      el.className = String(value);
-    } else if (key === "value" || key === "checked") {
-      applyFormControlProp(el, key, value, tagName);
-    } else {
-      el.setAttribute(key, String(value));
+  }
+  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 applyFormControlProp(el, key, value, tagName) {
-  const tag = tagName.toLowerCase();
-  if (key === "value") {
-    if (tag === "input" || tag === "textarea" || tag === "select") {
-      el.value = String(value);
-      el.setAttribute("value", String(value));
-    } else {
-      el.setAttribute("value", String(value));
-    }
-  } else if (key === "checked") {
-    if (tag === "input") {
-      el.checked = Boolean(value);
-      el.setAttribute("checked", String(Boolean(value)));
-    } else {
-      el.setAttribute("checked", String(Boolean(value)));
+function unwrapFragmentForFastPath(vnode) {
+  if (!vnode || typeof vnode !== "object" || !("type" in vnode)) return vnode;
+  const v = vnode;
+  if (typeof v.type === "symbol" && (v.type === Fragment || String(v.type) === "Symbol(askr.fragment)")) {
+    const children = v.children || v.props?.children;
+    if (Array.isArray(children) && children.length > 0) {
+      for (const child of children) {
+        if (child && typeof child === "object" && "type" in child) {
+          const c = child;
+          if (typeof c.type === "string") {
+            return child;
+          }
+        }
+      }
     }
   }
+  return vnode;
 }
-function materializeKey(el, vnode, props) {
-  const vnodeKey = vnode.key ?? props?.key;
-  if (vnodeKey !== void 0) {
-    el.setAttribute("data-key", String(vnodeKey));
+function classifyUpdate(instance, result) {
+  const unwrappedResult = unwrapFragmentForFastPath(result);
+  if (!unwrappedResult || typeof unwrappedResult !== "object" || !("type" in unwrappedResult))
+    return { useFastPath: false, reason: "not-vnode" };
+  const vnode = unwrappedResult;
+  if (vnode == null || typeof vnode.type !== "string")
+    return { useFastPath: false, reason: "not-intrinsic" };
+  const parent = instance.target;
+  if (!parent) return { useFastPath: false, reason: "no-root" };
+  const firstChild = parent.children[0];
+  if (!firstChild) return { useFastPath: false, reason: "no-first-child" };
+  if (firstChild.tagName.toLowerCase() !== String(vnode.type).toLowerCase())
+    return { useFastPath: false, reason: "root-tag-mismatch" };
+  const children = vnode.children || vnode.props?.children;
+  if (!Array.isArray(children))
+    return { useFastPath: false, reason: "no-children-array" };
+  for (const c of children) {
+    if (typeof c === "object" && c !== null && "type" in c && typeof c.type === "function") {
+      return { useFastPath: false, reason: "component-child-present" };
+    }
   }
+  if (instance.mountOperations.length > 0)
+    return { useFastPath: false, reason: "pending-mounts" };
+  try {
+    populateKeyMapForElement(firstChild);
+  } catch {
+  }
+  const oldKeyMap = getKeyMapForElement(firstChild);
+  const decision = isKeyedReorderFastPathEligible(
+    firstChild,
+    children,
+    oldKeyMap
+  );
+  if (!decision.useFastPath || decision.totalKeyed < 128)
+    return { ...decision, useFastPath: false, reason: "renderer-declined" };
+  return { ...decision, useFastPath: true };
 }
-function warnMissingKeys(children) {
-  if (process.env.NODE_ENV === "production") return;
-  let hasElements = false;
-  let hasKeys = false;
-  for (const item of children) {
-    if (typeof item === "object" && item !== null && "type" in item) {
-      hasElements = true;
-      const rawKey = item.key ?? item.props?.key;
-      if (rawKey !== void 0) {
-        hasKeys = true;
-        break;
+function commitReorderOnly(instance, result) {
+  const evaluate2 = globalThis.__ASKR_RENDERER?.evaluate;
+  if (typeof evaluate2 !== "function") {
+    logger.warn(
+      "[Tempo][FASTPATH][DEV] renderer.evaluate not available; declining fast-lane"
+    );
+    return false;
+  }
+  const schedBefore = process.env.NODE_ENV !== "production" ? globalScheduler.getState() : null;
+  enterBulkCommit();
+  try {
+    globalScheduler.runWithSyncProgress(() => {
+      evaluate2(result, instance.target);
+      try {
+        finalizeReadSubscriptions(instance);
+      } catch (e) {
+        if (process.env.NODE_ENV !== "production") throw e;
       }
+    });
+    const clearedAfter = globalScheduler.clearPendingSyncTasks?.() ?? 0;
+    setDevValue("__FASTLANE_CLEARED_AFTER", clearedAfter);
+    if (process.env.NODE_ENV !== "production") {
+      validateFastLaneInvariants(instance, schedBefore);
     }
+    return true;
+  } finally {
+    exitBulkCommit();
   }
-  if (hasElements && !hasKeys) {
-    try {
-      const inst = getCurrentInstance();
-      const name = inst?.fn?.name || "<anonymous>";
-      logger.warn(
-        `Missing keys on dynamic lists in ${name}. Each child in a list should have a unique "key" prop.`
-      );
-    } catch {
-      logger.warn(
-        'Missing keys on dynamic lists. Each child in a list should have a unique "key" prop.'
+  if (process.env.NODE_ENV !== "production") {
+    if (isBulkCommitActive2()) {
+      throw new Error(
+        "Fast-lane invariant violated: bulk commit flag still set after commit"
       );
     }
   }
 }
-function createDOMNode(node) {
-  if (!IS_DOM_AVAILABLE) {
-    if (process.env.NODE_ENV !== "production") {
-      try {
-        logger.warn("[Askr] createDOMNode called in non-DOM environment");
-      } catch {
-      }
-    }
-    return null;
+function validateFastLaneInvariants(instance, schedBefore) {
+  const commitCount = getDevValue("__LAST_FASTPATH_COMMIT_COUNT") ?? 0;
+  const invariants = {
+    commitCount,
+    mountOps: instance.mountOperations.length,
+    cleanupFns: instance.cleanupFns.length
+  };
+  setDevValue("__LAST_FASTLANE_INVARIANTS", invariants);
+  if (commitCount !== 1) {
+    console.error(
+      "[FASTLANE][INV] commitCount",
+      commitCount,
+      "diag",
+      globalThis.__ASKR_DIAG
+    );
+    throw new Error(
+      "Fast-lane invariant violated: expected exactly one DOM commit during reorder-only commit"
+    );
   }
-  if (typeof node === "string") {
-    return document.createTextNode(node);
+  if (invariants.mountOps > 0) {
+    throw new Error(
+      "Fast-lane invariant violated: mount operations were registered during bulk commit"
+    );
   }
-  if (typeof node === "number") {
-    return document.createTextNode(String(node));
+  if (invariants.cleanupFns > 0) {
+    throw new Error(
+      "Fast-lane invariant violated: cleanup functions were added during bulk commit"
+    );
   }
-  if (!node) {
-    return null;
+  const schedAfter = globalScheduler.getState();
+  if (schedBefore && schedAfter && schedAfter.taskCount > schedBefore.taskCount) {
+    console.error(
+      "[FASTLANE] schedBefore, schedAfter",
+      schedBefore,
+      schedAfter
+    );
+    console.error("[FASTLANE] enqueue logs", getDevValue("__ENQUEUE_LOGS"));
+    throw new Error(
+      "Fast-lane invariant violated: scheduler enqueued leftover work during bulk commit"
+    );
   }
-  if (Array.isArray(node)) {
-    const fragment = document.createDocumentFragment();
-    for (const child of node) {
-      const dom = createDOMNode(child);
-      if (dom) fragment.appendChild(dom);
+  let finalState = globalScheduler.getState();
+  const executing = globalScheduler.isExecuting();
+  let outstandingAfter = Math.max(
+    0,
+    finalState.taskCount - (executing ? 1 : 0)
+  );
+  if (outstandingAfter !== 0) {
+    let attempts = 0;
+    while (attempts < 5) {
+      const cleared = globalScheduler.clearPendingSyncTasks?.() ?? 0;
+      if (cleared === 0) break;
+      attempts++;
     }
-    return fragment;
-  }
-  if (typeof node === "object" && node !== null && "type" in node) {
-    const type = node.type;
-    const props = node.props || {};
-    if (typeof type === "string") {
-      return createIntrinsicElement(node, type, props);
-    }
-    if (typeof type === "function") {
-      return createComponentElement(node, type, props);
-    }
-    if (typeof type === "symbol" && (type === Fragment2 || String(type) === "Symbol(Fragment)")) {
-      return createFragmentElement(node, props);
+    finalState = globalScheduler.getState();
+    outstandingAfter = Math.max(
+      0,
+      finalState.taskCount - (globalScheduler.isExecuting() ? 1 : 0)
+    );
+    if (outstandingAfter !== 0) {
+      console.error(
+        "[FASTLANE] Post-commit enqueue logs:",
+        getDevValue("__ENQUEUE_LOGS")
+      );
+      console.error(
+        "[FASTLANE] Cleared counts:",
+        getDevValue("__FASTLANE_CLEARED_TASKS"),
+        getDevValue("__FASTLANE_CLEARED_AFTER")
+      );
+      throw new Error(
+        `Fast-lane invariant violated: scheduler has ${finalState.taskCount} pending task(s) after commit`
+      );
     }
   }
-  return null;
 }
-function createIntrinsicElement(node, type, props) {
-  const el = document.createElement(type);
-  materializeKey(el, node, props);
-  applyPropsToElement(el, props, type);
-  const children = props.children || node.children;
-  if (children) {
-    if (Array.isArray(children)) {
-      warnMissingKeys(children);
-      for (const child of children) {
-        const dom = createDOMNode(child);
-        if (dom) el.appendChild(dom);
-      }
-    } else {
-      const dom = createDOMNode(children);
-      if (dom) el.appendChild(dom);
+function tryRuntimeFastLaneSync(instance, result) {
+  const cls = classifyUpdate(instance, result);
+  if (!cls.useFastPath) {
+    setDevValue("__LAST_FASTPATH_STATS", void 0);
+    setDevValue("__LAST_FASTPATH_COMMIT_COUNT", 0);
+    return false;
+  }
+  try {
+    return commitReorderOnly(instance, result);
+  } catch (err) {
+    if (process.env.NODE_ENV !== "production") throw err;
+    return false;
+  }
+}
+var _bulkCommitActive, _appliedParents;
+var init_fastlane = __esm({
+  "src/runtime/fastlane.ts"() {
+    "use strict";
+    init_scheduler();
+    init_logger();
+    init_keyed();
+    init_jsx();
+    init_dev_namespace();
+    _bulkCommitActive = false;
+    _appliedParents = null;
+    if (typeof globalThis !== "undefined") {
+      globalThis.__ASKR_FASTLANE = {
+        isBulkCommitActive: isBulkCommitActive2,
+        enterBulkCommit,
+        exitBulkCommit,
+        tryRuntimeFastLaneSync,
+        markFastPathApplied,
+        isFastPathApplied
+      };
     }
   }
-  return el;
+});
+
+// src/common/vnode.ts
+function _isDOMElement(node) {
+  return typeof node === "object" && node !== null && "type" in node;
 }
-function createComponentElement(node, type, props) {
-  const frame = node[CONTEXT_FRAME_SYMBOL];
-  const snapshot = frame || getCurrentContextFrame();
-  const componentFn = type;
-  const isAsync = componentFn.constructor.name === "AsyncFunction";
-  if (isAsync) {
-    throw new Error(
-      "Async components are not supported. Use resource() for async work."
-    );
+var init_vnode = __esm({
+  "src/common/vnode.ts"() {
+    "use strict";
   }
-  let childInstance = node.__instance;
-  if (!childInstance) {
-    childInstance = createComponentInstance(
-      `comp-${Math.random().toString(36).slice(2, 7)}`,
-      componentFn,
-      props || {},
-      null
-    );
-    node.__instance = childInstance;
+});
+
+// src/renderer/types.ts
+var init_types = __esm({
+  "src/renderer/types.ts"() {
+    "use strict";
+    init_vnode();
   }
-  if (snapshot) {
-    childInstance.ownerFrame = snapshot;
+});
+
+// src/renderer/cleanup.ts
+function cleanupSingleInstance(node, errors, strict) {
+  const inst = node.__ASKR_INSTANCE;
+  if (!inst) return;
+  try {
+    cleanupComponent(inst);
+  } catch (err) {
+    if (strict) errors.push(err);
+    else logger.warn("[Askr] cleanupComponent failed:", err);
   }
-  const result = withContext(
-    snapshot,
-    () => renderComponentInline(childInstance)
-  );
-  if (result instanceof Promise) {
-    throw new Error(
-      "Async components are not supported. Components must return synchronously."
-    );
+  try {
+    delete node.__ASKR_INSTANCE;
+  } catch (e) {
+    if (strict) errors.push(e);
   }
-  const dom = withContext(snapshot, () => createDOMNode(result));
-  if (dom instanceof Element) {
-    mountInstanceInline(childInstance, dom);
-    return dom;
+}
+function forEachDescendantElement(root, visit) {
+  try {
+    const doc = root.ownerDocument;
+    const createTreeWalker = doc?.createTreeWalker;
+    if (typeof createTreeWalker === "function") {
+      const walker = createTreeWalker.call(doc, root, 1);
+      let n = walker.firstChild();
+      while (n) {
+        visit(n);
+        n = walker.nextNode();
+      }
+      return;
+    }
+  } catch {
   }
-  if (!dom) {
-    const placeholder = document.createComment("");
-    childInstance._placeholder = placeholder;
-    childInstance.mounted = true;
-    childInstance.notifyUpdate = childInstance._enqueueRun;
-    return placeholder;
+  const descendants = root.querySelectorAll("*");
+  for (let i = 0; i < descendants.length; i++) {
+    visit(descendants[i]);
   }
-  const host = document.createElement("div");
-  host.appendChild(dom);
-  mountInstanceInline(childInstance, host);
-  return host;
 }
-function createFragmentElement(node, props) {
-  const fragment = document.createDocumentFragment();
-  const children = props.children || node.children;
-  if (children) {
-    if (Array.isArray(children)) {
-      for (const child of children) {
-        const dom = createDOMNode(child);
-        if (dom) fragment.appendChild(dom);
+function cleanupInstanceIfPresent(node, opts) {
+  if (!node || !(node instanceof Element)) return;
+  const strict = opts?.strict ?? false;
+  const errors = strict ? [] : null;
+  try {
+    cleanupSingleInstance(node, errors, strict);
+  } catch (err) {
+    if (strict) errors.push(err);
+    else logger.warn("[Askr] cleanupInstanceIfPresent failed:", err);
+  }
+  try {
+    forEachDescendantElement(node, (d) => {
+      try {
+        cleanupSingleInstance(d, errors, strict);
+      } catch (err) {
+        if (strict) errors.push(err);
+        else
+          logger.warn(
+            "[Askr] cleanupInstanceIfPresent descendant cleanup failed:",
+            err
+          );
       }
-    } else {
-      const dom = createDOMNode(children);
-      if (dom) fragment.appendChild(dom);
+    });
+  } catch (err) {
+    if (strict) errors.push(err);
+    else
+      logger.warn(
+        "[Askr] cleanupInstanceIfPresent descendant query failed:",
+        err
+      );
+  }
+  if (errors && errors.length > 0) {
+    throw new AggregateError(errors, "cleanupInstanceIfPresent failed");
+  }
+}
+function cleanupInstancesUnder(node, opts) {
+  cleanupInstanceIfPresent(node, opts);
+}
+function removeElementListeners(element) {
+  const map = elementListeners.get(element);
+  if (map) {
+    for (const [eventName, entry] of map) {
+      if (entry.options !== void 0)
+        element.removeEventListener(eventName, entry.handler, entry.options);
+      else element.removeEventListener(eventName, entry.handler);
     }
+    elementListeners.delete(element);
   }
-  return fragment;
 }
-function updateElementFromVnode(el, vnode, updateChildren = true) {
-  if (!_isDOMElement(vnode)) {
-    return;
+function removeAllListeners(root) {
+  if (!root) return;
+  removeElementListeners(root);
+  forEachDescendantElement(root, removeElementListeners);
+}
+var elementListeners;
+var init_cleanup = __esm({
+  "src/renderer/cleanup.ts"() {
+    "use strict";
+    init_component();
+    init_logger();
+    elementListeners = /* @__PURE__ */ new WeakMap();
   }
-  const props = vnode.props || {};
-  materializeKey(el, vnode, props);
-  const existingListeners = elementListeners.get(el);
-  const desiredEventNames = /* @__PURE__ */ new Set();
+});
+
+// src/jsx/types.ts
+var init_types2 = __esm({
+  "src/jsx/types.ts"() {
+    "use strict";
+    init_jsx();
+  }
+});
+
+// src/jsx/jsx-runtime.ts
+var Fragment2;
+var init_jsx_runtime = __esm({
+  "src/jsx/jsx-runtime.ts"() {
+    "use strict";
+    init_types2();
+    Fragment2 = /* @__PURE__ */ Symbol.for("askr.fragment");
+  }
+});
+
+// src/renderer/dom.ts
+function addTrackedListener(el, eventName, handler) {
+  const wrappedHandler = createWrappedHandler(handler, true);
+  const options = getPassiveOptions(eventName);
+  if (options !== void 0) {
+    el.addEventListener(eventName, wrappedHandler, options);
+  } else {
+    el.addEventListener(eventName, wrappedHandler);
+  }
+  if (!elementListeners.has(el)) {
+    elementListeners.set(el, /* @__PURE__ */ new Map());
+  }
+  elementListeners.get(el).set(eventName, {
+    handler: wrappedHandler,
+    original: handler,
+    options
+  });
+}
+function applyPropsToElement(el, props, tagName) {
   for (const key in props) {
     const value = props[key];
     if (isSkippedProp(key)) continue;
+    if (value === void 0 || value === null || value === false) continue;
     const eventName = parseEventName(key);
-    if (value === void 0 || value === null || value === false) {
+    if (eventName) {
+      addTrackedListener(el, eventName, value);
+      continue;
+    }
+    if (key === "class" || key === "className") {
+      el.className = String(value);
+    } else if (key === "value" || key === "checked") {
+      applyFormControlProp(el, key, value, tagName);
+    } else {
+      el.setAttribute(key, String(value));
+    }
+  }
+}
+function applyFormControlProp(el, key, value, tagName) {
+  if (key === "value") {
+    if (tagNamesEqualIgnoreCase(tagName, "input") || tagNamesEqualIgnoreCase(tagName, "textarea") || tagNamesEqualIgnoreCase(tagName, "select")) {
+      el.value = String(value);
+      el.setAttribute("value", String(value));
+    } else {
+      el.setAttribute("value", String(value));
+    }
+  } else if (key === "checked") {
+    if (tagNamesEqualIgnoreCase(tagName, "input")) {
+      el.checked = Boolean(value);
+      el.setAttribute("checked", String(Boolean(value)));
+    } else {
+      el.setAttribute("checked", String(Boolean(value)));
+    }
+  }
+}
+function materializeKey(el, vnode, props) {
+  const vnodeKey = vnode.key ?? props?.key;
+  if (vnodeKey !== void 0) {
+    el.setAttribute("data-key", String(vnodeKey));
+  }
+}
+function warnMissingKeys(children) {
+  if (process.env.NODE_ENV === "production") return;
+  let hasElements = false;
+  let hasKeys = false;
+  for (const item of children) {
+    if (typeof item === "object" && item !== null && "type" in item) {
+      hasElements = true;
+      const rawKey = item.key ?? item.props?.key;
+      if (rawKey !== void 0) {
+        hasKeys = true;
+        break;
+      }
+    }
+  }
+  if (hasElements && !hasKeys) {
+    try {
+      const inst = getCurrentInstance();
+      const name = inst?.fn?.name || "<anonymous>";
+      logger.warn(
+        `Missing keys on dynamic lists in ${name}. Each child in a list should have a unique "key" prop.`
+      );
+    } catch {
+      logger.warn(
+        'Missing keys on dynamic lists. Each child in a list should have a unique "key" prop.'
+      );
+    }
+  }
+}
+function createDOMNode(node) {
+  if (!IS_DOM_AVAILABLE) {
+    if (process.env.NODE_ENV !== "production") {
+      try {
+        logger.warn("[Askr] createDOMNode called in non-DOM environment");
+      } catch {
+      }
+    }
+    return null;
+  }
+  if (typeof node === "string") {
+    return document.createTextNode(node);
+  }
+  if (typeof node === "number") {
+    return document.createTextNode(String(node));
+  }
+  if (!node) {
+    return null;
+  }
+  if (Array.isArray(node)) {
+    const fragment = document.createDocumentFragment();
+    for (const child of node) {
+      const dom = createDOMNode(child);
+      if (dom) fragment.appendChild(dom);
+    }
+    return fragment;
+  }
+  if (typeof node === "object" && node !== null && "type" in node) {
+    const type = node.type;
+    const props = node.props || {};
+    if (typeof type === "string") {
+      return createIntrinsicElement(node, type, props);
+    }
+    if (typeof type === "function") {
+      return createComponentElement(node, type, props);
+    }
+    if (typeof type === "symbol" && (type === Fragment2 || String(type) === "Symbol(Fragment)")) {
+      return createFragmentElement(node, props);
+    }
+  }
+  return null;
+}
+function createIntrinsicElement(node, type, props) {
+  const el = document.createElement(type);
+  materializeKey(el, node, props);
+  applyPropsToElement(el, props, type);
+  const children = props.children || node.children;
+  if (children) {
+    if (Array.isArray(children)) {
+      warnMissingKeys(children);
+      for (const child of children) {
+        const dom = createDOMNode(child);
+        if (dom) el.appendChild(dom);
+      }
+    } else {
+      const dom = createDOMNode(children);
+      if (dom) el.appendChild(dom);
+    }
+  }
+  return el;
+}
+function createComponentElement(node, type, props) {
+  const frame = node[CONTEXT_FRAME_SYMBOL];
+  const snapshot = frame || getCurrentContextFrame();
+  const componentFn = type;
+  const isAsync = componentFn.constructor.name === "AsyncFunction";
+  if (isAsync) {
+    throw new Error(
+      "Async components are not supported. Use resource() for async work."
+    );
+  }
+  let childInstance = node.__instance;
+  if (!childInstance) {
+    childInstance = createComponentInstance(
+      `comp-${Math.random().toString(36).slice(2, 7)}`,
+      componentFn,
+      props || {},
+      null
+    );
+    node.__instance = childInstance;
+  }
+  if (snapshot) {
+    childInstance.ownerFrame = snapshot;
+  }
+  const result = withContext(
+    snapshot,
+    () => renderComponentInline(childInstance)
+  );
+  if (result instanceof Promise) {
+    throw new Error(
+      "Async components are not supported. Components must return synchronously."
+    );
+  }
+  const dom = withContext(snapshot, () => createDOMNode(result));
+  if (dom instanceof Element) {
+    mountInstanceInline(childInstance, dom);
+    return dom;
+  }
+  if (!dom) {
+    const placeholder = document.createComment("");
+    childInstance._placeholder = placeholder;
+    childInstance.mounted = true;
+    childInstance.notifyUpdate = childInstance._enqueueRun;
+    return placeholder;
+  }
+  const host = document.createElement("div");
+  host.appendChild(dom);
+  mountInstanceInline(childInstance, host);
+  return host;
+}
+function createFragmentElement(node, props) {
+  const fragment = document.createDocumentFragment();
+  const children = props.children || node.children;
+  if (children) {
+    if (Array.isArray(children)) {
+      for (const child of children) {
+        const dom = createDOMNode(child);
+        if (dom) fragment.appendChild(dom);
+      }
+    } else {
+      const dom = createDOMNode(children);
+      if (dom) fragment.appendChild(dom);
+    }
+  }
+  return fragment;
+}
+function updateElementFromVnode(el, vnode, updateChildren = true) {
+  if (!_isDOMElement(vnode)) {
+    return;
+  }
+  const props = vnode.props || {};
+  materializeKey(el, vnode, props);
+  const existingListeners = elementListeners.get(el);
+  let desiredEventNames = null;
+  for (const key in props) {
+    const value = props[key];
+    if (isSkippedProp(key)) continue;
+    const eventName = parseEventName(key);
+    if (value === void 0 || value === null || value === false) {
       if (key === "class" || key === "className") {
         el.className = "";
       } else if (eventName && existingListeners?.has(eventName)) {
@@ -1268,13 +1363,19 @@ function updateElementFromVnode(el, vnode, updateChildren = true) {
     } else if (key === "value" || key === "checked") {
       el[key] = value;
     } else if (eventName) {
-      desiredEventNames.add(eventName);
+      if (existingListeners && existingListeners.size > 0) {
+        (desiredEventNames ??= /* @__PURE__ */ new Set()).add(eventName);
+      }
       const existing = existingListeners?.get(eventName);
       if (existing && existing.original === value) {
         continue;
       }
       if (existing) {
-        el.removeEventListener(eventName, existing.handler);
+        if (existing.options !== void 0) {
+          el.removeEventListener(eventName, existing.handler, existing.options);
+        } else {
+          el.removeEventListener(eventName, existing.handler);
+        }
       }
       const wrappedHandler = createWrappedHandler(
         value,
@@ -1298,15 +1399,29 @@ function updateElementFromVnode(el, vnode, updateChildren = true) {
       el.setAttribute(key, String(value));
     }
   }
-  if (existingListeners) {
-    for (const eventName of existingListeners.keys()) {
-      if (!desiredEventNames.has(eventName)) {
-        const entry = existingListeners.get(eventName);
-        el.removeEventListener(eventName, entry.handler);
-        existingListeners.delete(eventName);
+  if (existingListeners && existingListeners.size > 0) {
+    if (desiredEventNames === null) {
+      for (const [eventName, entry] of existingListeners) {
+        if (entry.options !== void 0) {
+          el.removeEventListener(eventName, entry.handler, entry.options);
+        } else {
+          el.removeEventListener(eventName, entry.handler);
+        }
+      }
+      elementListeners.delete(el);
+    } else {
+      for (const [eventName, entry] of existingListeners) {
+        if (!desiredEventNames.has(eventName)) {
+          if (entry.options !== void 0) {
+            el.removeEventListener(eventName, entry.handler, entry.options);
+          } else {
+            el.removeEventListener(eventName, entry.handler);
+          }
+          existingListeners.delete(eventName);
+        }
       }
+      if (existingListeners.size === 0) elementListeners.delete(el);
     }
-    if (existingListeners.size === 0) elementListeners.delete(el);
   }
   if (updateChildren) {
     const children = vnode.children || props.children;
@@ -1349,47 +1464,47 @@ function updateUnkeyedChildren(parent, newChildren) {
   }
   const max = Math.max(existing.length, newChildren.length);
   for (let i = 0; i < max; i++) {
-    const current2 = existing[i];
+    const current = existing[i];
     const next = newChildren[i];
-    if (next === void 0 && current2) {
-      cleanupInstanceIfPresent(current2);
-      current2.remove();
+    if (next === void 0 && current) {
+      cleanupInstanceIfPresent(current);
+      current.remove();
       continue;
     }
-    if (!current2 && next !== void 0) {
+    if (!current && next !== void 0) {
       const dom = createDOMNode(next);
       if (dom) parent.appendChild(dom);
       continue;
     }
-    if (!current2 || next === void 0) continue;
+    if (!current || next === void 0) continue;
     if (typeof next === "string" || typeof next === "number") {
-      current2.textContent = String(next);
+      current.textContent = String(next);
     } else if (_isDOMElement(next)) {
       if (typeof next.type === "string") {
-        if (current2.tagName.toLowerCase() === next.type.toLowerCase()) {
-          updateElementFromVnode(current2, next);
+        if (tagsEqualIgnoreCase(current.tagName, next.type)) {
+          updateElementFromVnode(current, next);
         } else {
           const dom = createDOMNode(next);
           if (dom) {
-            if (current2 instanceof Element) removeAllListeners(current2);
-            cleanupInstanceIfPresent(current2);
-            parent.replaceChild(dom, current2);
+            if (current instanceof Element) removeAllListeners(current);
+            cleanupInstanceIfPresent(current);
+            parent.replaceChild(dom, current);
           }
         }
       } else {
         const dom = createDOMNode(next);
         if (dom) {
-          if (current2 instanceof Element) removeAllListeners(current2);
-          cleanupInstanceIfPresent(current2);
-          parent.replaceChild(dom, current2);
+          if (current instanceof Element) removeAllListeners(current);
+          cleanupInstanceIfPresent(current);
+          parent.replaceChild(dom, current);
         }
       }
     } else {
       const dom = createDOMNode(next);
       if (dom) {
-        if (current2 instanceof Element) removeAllListeners(current2);
-        cleanupInstanceIfPresent(current2);
-        parent.replaceChild(dom, current2);
+        if (current instanceof Element) removeAllListeners(current);
+        cleanupInstanceIfPresent(current);
+        parent.replaceChild(dom, current);
       }
     }
   }
@@ -1399,31 +1514,38 @@ function performBulkPositionalKeyedTextUpdate(parent, keyedVnodes) {
   let reused = 0;
   let updatedKeys = 0;
   const t0 = now();
+  const debugFastPath = process.env.ASKR_FASTPATH_DEBUG === "1" || process.env.ASKR_FASTPATH_DEBUG === "true";
   for (let i = 0; i < total; i++) {
     const { key, vnode } = keyedVnodes[i];
     const ch = parent.children[i];
     if (ch && _isDOMElement(vnode) && typeof vnode.type === "string") {
       const vnodeType = vnode.type;
-      if (ch.tagName.toLowerCase() === vnodeType.toLowerCase()) {
+      if (tagsEqualIgnoreCase(ch.tagName, vnodeType)) {
         const children = vnode.children || vnode.props?.children;
-        logFastPathDebug("positional idx", i, {
-          chTag: ch.tagName.toLowerCase(),
-          vnodeType,
-          chChildNodes: ch.childNodes.length,
-          childrenType: Array.isArray(children) ? "array" : typeof children
-        });
-        updateTextContent(ch, children);
+        if (debugFastPath) {
+          logFastPathDebug("positional idx", i, {
+            chTag: ch.tagName,
+            vnodeType,
+            chChildNodes: ch.childNodes.length,
+            childrenType: Array.isArray(children) ? "array" : typeof children
+          });
+        }
+        updateTextContent(ch, children, vnode);
         setDataKey(ch, key, () => updatedKeys++);
         reused++;
         continue;
       } else {
-        logFastPathDebug("positional tag mismatch", i, {
-          chTag: ch.tagName.toLowerCase(),
-          vnodeType
-        });
+        if (debugFastPath) {
+          logFastPathDebug("positional tag mismatch", i, {
+            chTag: ch.tagName,
+            vnodeType
+          });
+        }
       }
     } else {
-      logFastPathDebug("positional missing or invalid", i, { ch: !!ch });
+      if (debugFastPath) {
+        logFastPathDebug("positional missing or invalid", i, { ch: !!ch });
+      }
     }
     replaceNodeAtPosition(parent, i, vnode);
   }
@@ -1433,14 +1555,46 @@ function performBulkPositionalKeyedTextUpdate(parent, keyedVnodes) {
   recordFastPathStats(stats, "bulkKeyedPositionalHits");
   return stats;
 }
-function updateTextContent(el, children) {
+function updateTextContent(el, children, vnode) {
   if (typeof children === "string" || typeof children === "number") {
     setTextNodeData(el, String(children));
   } else if (Array.isArray(children) && children.length === 1 && (typeof children[0] === "string" || typeof children[0] === "number")) {
     setTextNodeData(el, String(children[0]));
   } else {
-    updateElementFromVnode(el, el);
+    if (!tryUpdateTwoChildTextPattern(el, vnode)) {
+      updateElementFromVnode(el, vnode);
+    }
+  }
+}
+function tryUpdateTwoChildTextPattern(parentEl, vnode) {
+  const vnodeChildren = vnode.children || vnode.props?.children;
+  if (!Array.isArray(vnodeChildren) || vnodeChildren.length !== 2) return false;
+  const c0 = vnodeChildren[0];
+  const c1 = vnodeChildren[1];
+  if (!_isDOMElement(c0) || !_isDOMElement(c1)) return false;
+  if (typeof c0.type !== "string" || typeof c1.type !== "string") return false;
+  const el0 = parentEl.children[0];
+  const el1 = parentEl.children[1];
+  if (!el0 || !el1) return false;
+  if (!tagsEqualIgnoreCase(el0.tagName, c0.type)) return false;
+  if (!tagsEqualIgnoreCase(el1.tagName, c1.type)) return false;
+  const t0 = c0.children || c0.props?.children;
+  const t1 = c1.children || c1.props?.children;
+  if (typeof t0 === "string" || typeof t0 === "number") {
+    setTextNodeData(el0, String(t0));
+  } else if (Array.isArray(t0) && t0.length === 1 && (typeof t0[0] === "string" || typeof t0[0] === "number")) {
+    setTextNodeData(el0, String(t0[0]));
+  } else {
+    return false;
+  }
+  if (typeof t1 === "string" || typeof t1 === "number") {
+    setTextNodeData(el1, String(t1));
+  } else if (Array.isArray(t1) && t1.length === 1 && (typeof t1[0] === "string" || typeof t1[0] === "number")) {
+    setTextNodeData(el1, String(t1[0]));
+  } else {
+    return false;
   }
+  return true;
 }
 function setTextNodeData(el, text) {
   if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
@@ -1451,11 +1605,56 @@ function setTextNodeData(el, text) {
 }
 function setDataKey(el, key, onSet) {
   try {
-    el.setAttribute("data-key", String(key));
+    const next = String(key);
+    if (el.getAttribute("data-key") === next) return;
+    el.setAttribute("data-key", next);
     onSet();
   } catch {
   }
 }
+function upperCommonTagName(tag) {
+  switch (tag) {
+    case "div":
+      return "DIV";
+    case "span":
+      return "SPAN";
+    case "p":
+      return "P";
+    case "a":
+      return "A";
+    case "button":
+      return "BUTTON";
+    case "input":
+      return "INPUT";
+    case "ul":
+      return "UL";
+    case "ol":
+      return "OL";
+    case "li":
+      return "LI";
+    default:
+      return null;
+  }
+}
+function tagNamesEqualIgnoreCase(a, b) {
+  if (a === b) return true;
+  const len = a.length;
+  if (len !== b.length) return false;
+  for (let i = 0; i < len; i++) {
+    const ac = a.charCodeAt(i);
+    const bc = b.charCodeAt(i);
+    if (ac === bc) continue;
+    const an = ac >= 65 && ac <= 90 ? ac + 32 : ac;
+    const bn = bc >= 65 && bc <= 90 ? bc + 32 : bc;
+    if (an !== bn) return false;
+  }
+  return true;
+}
+function tagsEqualIgnoreCase(elementTagName, vnodeType) {
+  const upperCommon = upperCommonTagName(vnodeType);
+  if (upperCommon !== null && elementTagName === upperCommon) return true;
+  return tagNamesEqualIgnoreCase(elementTagName, vnodeType);
+}
 function replaceNodeAtPosition(parent, index, vnode) {
   const dom = createDOMNode(vnode);
   if (dom) {
@@ -1470,7 +1669,8 @@ function replaceNodeAtPosition(parent, index, vnode) {
 }
 function updateKeyedElementsMap(parent, keyedVnodes) {
   try {
-    const newKeyMap = /* @__PURE__ */ new Map();
+    const existing = keyedElements.get(parent);
+    const newKeyMap = existing ? (existing.clear(), existing) : /* @__PURE__ */ new Map();
     for (let i = 0; i < keyedVnodes.length; i++) {
       const k = keyedVnodes[i].key;
       const ch = parent.children[i];
@@ -1492,7 +1692,6 @@ function performBulkTextReplace(parent, newChildren) {
     else if (result === "created") created++;
   }
   const tBuild = now() - t0;
-  cleanupRemovedNodes(parent, finalNodes);
   const tCommit = commitBulkReplace(parent, finalNodes);
   keyedElements.delete(parent);
   const stats = {
@@ -1527,7 +1726,7 @@ function processElementVnode(vnode, existingNode, finalNodes) {
   const vnodeObj = vnode;
   if (typeof vnodeObj.type === "string") {
     const tag = vnodeObj.type;
-    if (existingNode && existingNode.nodeType === 1 && existingNode.tagName.toLowerCase() === tag.toLowerCase()) {
+    if (existingNode && existingNode.nodeType === 1 && tagsEqualIgnoreCase(existingNode.tagName, tag)) {
       updateElementFromVnode(existingNode, vnode);
       finalNodes.push(existingNode);
       return "reused";
@@ -1540,24 +1739,21 @@ function processElementVnode(vnode, existingNode, finalNodes) {
   }
   return "skipped";
 }
-function cleanupRemovedNodes(parent, keepNodes) {
-  try {
-    const toRemove = Array.from(parent.childNodes).filter(
-      (n) => !keepNodes.includes(n)
-    );
-    for (const n of toRemove) {
-      if (n instanceof Element) removeAllListeners(n);
-      cleanupInstanceIfPresent(n);
-    }
-  } catch {
-  }
-}
 function commitBulkReplace(parent, nodes) {
   const fragStart = Date.now();
   const fragment = document.createDocumentFragment();
   for (let i = 0; i < nodes.length; i++) {
     fragment.appendChild(nodes[i]);
   }
+  try {
+    for (let n = parent.firstChild; n; ) {
+      const next = n.nextSibling;
+      if (n instanceof Element) removeAllListeners(n);
+      cleanupInstanceIfPresent(n);
+      n = next;
+    }
+  } catch {
+  }
   recordDOMReplace("bulk-text-replace");
   parent.replaceChildren(fragment);
   return Date.now() - fragStart;
@@ -1687,9 +1883,7 @@ function applyRendererFastPath(parent, keyedVnodes, oldKeyMap, unkeyedVnodes) {
   } else {
     localOldKeyMap = /* @__PURE__ */ new Map();
     try {
-      const parentChildren = Array.from(parent.children);
-      for (let i = 0; i < parentChildren.length; i++) {
-        const ch = parentChildren[i];
+      for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {
         const k = ch.getAttribute("data-key");
         if (k !== null) {
           localOldKeyMap.set(k, ch);
@@ -1753,11 +1947,11 @@ function applyRendererFastPath(parent, keyedVnodes, oldKeyMap, unkeyedVnodes) {
       fragmentAppendCount++;
     }
     try {
-      const existing = Array.from(parent.childNodes);
-      const toRemove = existing.filter((n) => !finalNodes.includes(n));
-      for (const n of toRemove) {
+      for (let n = parent.firstChild; n; ) {
+        const next = n.nextSibling;
         if (n instanceof Element) removeAllListeners(n);
         cleanupInstanceIfPresent(n);
+        n = next;
       }
     } catch (e) {
       void e;
@@ -1833,14 +2027,26 @@ var init_fastpath = __esm({
     init_cleanup();
     init_diag();
     init_scheduler();
-    init_fastlane_shared();
+    init_fastlane();
   }
 });
 
 // src/renderer/reconcile.ts
-function reconcileKeyedChildren(parent, newChildren, oldKeyMap) {
-  logReconcileDebug(newChildren);
-  const { keyedVnodes, unkeyedVnodes } = partitionChildren(newChildren);
+function tagNamesEqualIgnoreCase2(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const ca = a.charCodeAt(i);
+    const cb = b.charCodeAt(i);
+    if (ca === cb) continue;
+    const fa = ca >= 65 && ca <= 90 ? ca + 32 : ca;
+    const fb = cb >= 65 && cb <= 90 ? cb + 32 : cb;
+    if (fa !== fb) return false;
+  }
+  return true;
+}
+function reconcileKeyedChildren(parent, newChildren, oldKeyMap) {
+  const { keyedVnodes, unkeyedVnodes } = partitionChildren(newChildren);
   const fastPathResult = tryFastPaths(
     parent,
     newChildren,
@@ -1851,20 +2057,6 @@ function reconcileKeyedChildren(parent, newChildren, oldKeyMap) {
   if (fastPathResult) return fastPathResult;
   return performFullReconciliation(parent, newChildren, keyedVnodes, oldKeyMap);
 }
-function logReconcileDebug(newChildren) {
-  if (process.env.NODE_ENV !== "production") {
-    try {
-      logger.warn(
-        "[Askr][RECONCILE] reconcileKeyedChildren newChildren sample",
-        {
-          sample: newChildren && newChildren.length && newChildren[0] || null,
-          len: newChildren.length
-        }
-      );
-    } catch {
-    }
-  }
-}
 function partitionChildren(newChildren) {
   const keyedVnodes = [];
   const unkeyedVnodes = [];
@@ -1922,7 +2114,6 @@ function tryPositionalBulkUpdate(parent, keyedVnodes) {
   const total = keyedVnodes.length;
   if (total < 10) return null;
   const matchCount = countPositionalMatches(parent, keyedVnodes);
-  logPositionalCheck(total, matchCount, parent.children.length);
   if (matchCount / total < 0.9) return null;
   if (hasPositionalPropChanges(parent, keyedVnodes)) return null;
   try {
@@ -1943,7 +2134,7 @@ function countPositionalMatches(parent, keyedVnodes) {
         continue;
       const el = parent.children[i];
       if (!el) continue;
-      if (el.tagName.toLowerCase() === String(vnode.type).toLowerCase()) {
+      if (tagNamesEqualIgnoreCase2(el.tagName, vnode.type)) {
         matchCount++;
       }
     }
@@ -1951,18 +2142,6 @@ function countPositionalMatches(parent, keyedVnodes) {
   }
   return matchCount;
 }
-function logPositionalCheck(total, matchCount, parentChildren) {
-  if (process.env.NODE_ENV !== "production") {
-    try {
-      logger.warn("[Askr][FASTPATH] positional check", {
-        total,
-        matchCount,
-        parentChildren
-      });
-    } catch {
-    }
-  }
-}
 function hasPositionalPropChanges(parent, keyedVnodes) {
   try {
     for (let i = 0; i < keyedVnodes.length; i++) {
@@ -1981,9 +2160,7 @@ function hasPositionalPropChanges(parent, keyedVnodes) {
 function rebuildKeyedMap(parent) {
   try {
     const map = /* @__PURE__ */ new Map();
-    const children = Array.from(parent.children);
-    for (let i = 0; i < children.length; i++) {
-      const el = children[i];
+    for (let el = parent.firstElementChild; el; el = el.nextElementSibling) {
       const k = el.getAttribute("data-key");
       if (k !== null) {
         map.set(k, el);
@@ -2044,18 +2221,19 @@ function createOldElResolver(parent, oldKeyMap, usedOldEls) {
 }
 function scanForElementByKey(parent, k, keyStr, usedOldEls) {
   try {
-    const children = Array.from(parent.children);
-    for (const ch of children) {
+    for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {
       if (usedOldEls.has(ch)) continue;
       const attr = ch.getAttribute("data-key");
       if (attr === keyStr) {
         usedOldEls.add(ch);
         return ch;
       }
-      const numAttr = Number(attr);
-      if (!Number.isNaN(numAttr) && numAttr === k) {
-        usedOldEls.add(ch);
-        return ch;
+      if (attr !== null) {
+        const numAttr = Number(attr);
+        if (!Number.isNaN(numAttr) && numAttr === k) {
+          usedOldEls.add(ch);
+          return ch;
+        }
       }
     }
   } catch {
@@ -2072,9 +2250,17 @@ function reconcileSingleChild(child, index, parent, resolveOldElOnce, usedOldEls
 function reconcileKeyedChild(child, key, parent, resolveOldElOnce, newKeyMap) {
   const el = resolveOldElOnce(key);
   if (el && el.parentElement === parent) {
-    updateElementFromVnode(el, child);
-    newKeyMap.set(key, el);
-    return el;
+    try {
+      const childObj = child;
+      if (childObj && typeof childObj === "object" && typeof childObj.type === "string") {
+        if (tagNamesEqualIgnoreCase2(el.tagName, childObj.type)) {
+          updateElementFromVnode(el, child);
+          newKeyMap.set(key, el);
+          return el;
+        }
+      }
+    } catch {
+    }
   }
   const dom = createDOMNode(child);
   if (dom) {
@@ -2111,13 +2297,16 @@ function canReuseElement(existing, child) {
   if (typeof child !== "object" || child === null || !("type" in child))
     return false;
   const childObj = child;
-  const hasNoKey = existing.getAttribute("data-key") === null || existing.getAttribute("data-key") === void 0;
-  return hasNoKey && typeof childObj.type === "string" && existing.tagName.toLowerCase() === String(childObj.type).toLowerCase();
+  const existingKey = existing.getAttribute("data-key");
+  const hasNoKey = existingKey === null || existingKey === void 0;
+  return hasNoKey && typeof childObj.type === "string" && tagNamesEqualIgnoreCase2(existing.tagName, childObj.type);
 }
 function findAvailableUnkeyedElement(parent, usedOldEls) {
-  return Array.from(parent.children).find(
-    (ch) => !usedOldEls.has(ch) && ch.getAttribute("data-key") === null
-  );
+  for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {
+    if (usedOldEls.has(ch)) continue;
+    if (ch.getAttribute("data-key") === null) return ch;
+  }
+  return void 0;
 }
 function tryReuseElement(avail, child, usedOldEls) {
   if (typeof child === "string" || typeof child === "number") {
@@ -2127,7 +2316,7 @@ function tryReuseElement(avail, child, usedOldEls) {
   }
   if (typeof child === "object" && child !== null && "type" in child) {
     const childObj = child;
-    if (typeof childObj.type === "string" && avail.tagName.toLowerCase() === String(childObj.type).toLowerCase()) {
+    if (typeof childObj.type === "string" && tagNamesEqualIgnoreCase2(avail.tagName, childObj.type)) {
       updateElementFromVnode(avail, child);
       usedOldEls.add(avail);
       return avail;
@@ -2141,10 +2330,11 @@ function commitReconciliation(parent, finalNodes) {
     fragment.appendChild(finalNodes[i]);
   }
   try {
-    const existing = Array.from(parent.childNodes);
-    for (const n of existing) {
+    for (let n = parent.firstChild; n; ) {
+      const next = n.nextSibling;
       if (n instanceof Element) removeAllListeners(n);
       cleanupInstanceIfPresent(n);
+      n = next;
     }
   } catch {
   }
@@ -2157,14 +2347,26 @@ var init_reconcile = __esm({
     init_dom();
     init_keyed();
     init_cleanup();
-    init_fastlane_shared();
+    init_fastlane();
     init_fastpath();
-    init_logger();
     init_utils();
   }
 });
 
 // src/renderer/evaluate.ts
+function tagNamesEqualIgnoreCase3(a, b) {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    const ca = a.charCodeAt(i);
+    const cb = b.charCodeAt(i);
+    if (ca === cb) continue;
+    const fa = ca >= 65 && ca <= 90 ? ca + 32 : ca;
+    const fb = cb >= 65 && cb <= 90 ? cb + 32 : cb;
+    if (fa !== fb) return false;
+  }
+  return true;
+}
 function checkSimpleText(vnodeChildren) {
   if (!Array.isArray(vnodeChildren)) {
     if (typeof vnodeChildren === "string" || typeof vnodeChildren === "number") {
@@ -2187,8 +2389,7 @@ function tryUpdateTextInPlace(element, text) {
 }
 function buildKeyMapFromDOM(parent) {
   const keyMap = /* @__PURE__ */ new Map();
-  const children = Array.from(parent.children);
-  for (const child of children) {
+  for (let child = parent.firstElementChild; child; child = child.nextElementSibling) {
     const k = child.getAttribute("data-key");
     if (k !== null) {
       keyMap.set(k, child);
@@ -2209,9 +2410,10 @@ function getOrBuildKeyMap(parent) {
   return keyMap.size > 0 ? keyMap : void 0;
 }
 function hasKeyedChildren(children) {
-  return children.some(
-    (child) => typeof child === "object" && child !== null && "key" in child
-  );
+  for (let i = 0; i < children.length; i++) {
+    if (extractKey(children[i]) !== void 0) return true;
+  }
+  return false;
 }
 function trackBulkTextStats(stats) {
   if (process.env.NODE_ENV !== "production") {
@@ -2328,12 +2530,16 @@ function smartUpdateElement(element, vnode) {
   updateElementFromVnode(element, vnode, false);
 }
 function processFragmentChildren(target, childArray) {
-  const existingChildren = Array.from(target.children);
+  let existingNode = target.firstElementChild;
   for (let i = 0; i < childArray.length; i++) {
     const childVnode = childArray[i];
-    const existingNode = existingChildren[i];
-    if (existingNode && _isDOMElement(childVnode) && typeof childVnode.type === "string" && existingNode.tagName.toLowerCase() === childVnode.type.toLowerCase()) {
+    const nextExisting = existingNode ? existingNode.nextElementSibling : null;
+    if (existingNode && _isDOMElement(childVnode) && typeof childVnode.type === "string" && tagNamesEqualIgnoreCase3(
+      existingNode.tagName,
+      childVnode.type
+    )) {
       smartUpdateElement(existingNode, childVnode);
+      existingNode = nextExisting;
       continue;
     }
     const newDom = createDOMNode(childVnode);
@@ -2344,39 +2550,29 @@ function processFragmentChildren(target, childArray) {
         target.appendChild(newDom);
       }
     }
+    existingNode = nextExisting;
   }
-  while (target.children.length > childArray.length) {
-    target.removeChild(target.lastChild);
+  while (existingNode) {
+    const next = existingNode.nextElementSibling;
+    target.removeChild(existingNode);
+    existingNode = next;
   }
 }
-function createWrappedEventHandler(handler) {
-  return (event) => {
-    globalScheduler.setInHandler(true);
-    try {
-      handler(event);
-    } catch (error) {
-      logger.error("[Askr] Event handler error:", error);
-    } finally {
-      globalScheduler.setInHandler(false);
-    }
-  };
-}
 function applyPropsToElement2(el, props) {
   for (const [key, value] of Object.entries(props)) {
     if (key === "children" || key === "key") continue;
     if (value === void 0 || value === null || value === false) continue;
-    if (key.startsWith("on") && key.length > 2) {
-      const eventName = key.slice(2).charAt(0).toLowerCase() + key.slice(3).toLowerCase();
-      const wrappedHandler = createWrappedEventHandler(value);
-      const options = eventName === "wheel" || eventName === "scroll" || eventName.startsWith("touch") ? { passive: true } : void 0;
-      if (options !== void 0) {
+    const eventName = parseEventName(key);
+    if (eventName) {
+      const wrappedHandler = createWrappedHandler(
+        value,
+        false
+      );
+      const options = getPassiveOptions(eventName);
+      if (options !== void 0)
         el.addEventListener(eventName, wrappedHandler, options);
-      } else {
-        el.addEventListener(eventName, wrappedHandler);
-      }
-      if (!elementListeners.has(el)) {
-        elementListeners.set(el, /* @__PURE__ */ new Map());
-      }
+      else el.addEventListener(eventName, wrappedHandler);
+      if (!elementListeners.has(el)) elementListeners.set(el, /* @__PURE__ */ new Map());
       elementListeners.get(el).set(eventName, {
         handler: wrappedHandler,
         original: value,
@@ -2426,11 +2622,11 @@ function evaluate(node, target, context) {
   }
   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;
+    let current = range.start.nextSibling;
+    while (current && current !== range.end) {
+      const next = current.nextSibling;
+      current.remove();
+      current = next;
     }
     const dom = createDOMNode(node);
     if (dom) {
@@ -2458,7 +2654,7 @@ function evaluate(node, target, context) {
       }
     }
     const firstChild = target.children[0];
-    if (firstChild && _isDOMElement(vnode) && typeof vnode.type === "string" && firstChild.tagName.toLowerCase() === vnode.type.toLowerCase()) {
+    if (firstChild && _isDOMElement(vnode) && typeof vnode.type === "string" && tagNamesEqualIgnoreCase3(firstChild.tagName, vnode.type)) {
       smartUpdateElement(firstChild, vnode);
     } else {
       target.textContent = "";
@@ -2476,7 +2672,6 @@ var domRanges;
 var init_evaluate = __esm({
   "src/renderer/evaluate.ts"() {
     "use strict";
-    init_scheduler();
     init_logger();
     init_cleanup();
     init_keyed();
@@ -2484,7 +2679,8 @@ var init_evaluate = __esm({
     init_types();
     init_dom();
     init_diag();
-    init_types2();
+    init_jsx();
+    init_utils();
     domRanges = /* @__PURE__ */ new WeakMap();
   }
 });
@@ -2564,23 +2760,6 @@ function createComponentInstance(id, fn, props, target) {
 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) {
@@ -2633,7 +2812,7 @@ function runComponent(instance) {
     globalScheduler.enqueue(() => {
       if (!instance.target && instance._placeholder) {
         if (result === null || result === void 0) {
-          finalizeReadSubscriptions(instance);
+          finalizeReadSubscriptions2(instance);
           return;
         }
         const placeholder = instance._placeholder;
@@ -2653,7 +2832,7 @@ function runComponent(instance) {
           instance.target = host;
           instance._placeholder = void 0;
           host.__ASKR_INSTANCE = instance;
-          finalizeReadSubscriptions(instance);
+          finalizeReadSubscriptions2(instance);
         } finally {
           currentInstance = oldInstance;
         }
@@ -2698,7 +2877,7 @@ function runComponent(instance) {
           } finally {
             currentInstance = oldInstance;
           }
-          finalizeReadSubscriptions(instance);
+          finalizeReadSubscriptions2(instance);
           instance.mounted = true;
           if (wasFirstMount && instance.mountOperations.length > 0) {
             executeMountOperations(instance);
@@ -2750,7 +2929,7 @@ function renderComponentInline(instance) {
   try {
     const result = executeComponentSync(instance);
     if (!hadToken) {
-      finalizeReadSubscriptions(instance);
+      finalizeReadSubscriptions2(instance);
     }
     return result;
   } finally {
@@ -2818,15 +2997,7 @@ function executeComponent(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) {
+function finalizeReadSubscriptions2(instance) {
   const newSet = instance._pendingReadStates ?? /* @__PURE__ */ new Set();
   const oldSet = instance._lastReadStates ?? /* @__PURE__ */ new Set();
   const token = instance._currentRenderToken;
@@ -2897,7 +3068,7 @@ var init_component = __esm({
     init_context();
     init_logger();
     init_diag();
-    init_fastlane_shared();
+    init_fastlane();
     init_renderer();
     currentInstance = null;
     stateIndex = 0;
@@ -2905,97 +3076,6 @@ var init_component = __esm({
   }
 });
 
-// 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) {
-  return { seed };
-}
-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, currentSSRContext;
-var init_context2 = __esm({
-  "src/ssr/context.ts"() {
-    "use strict";
-    init_errors();
-    current = null;
-    currentSSRContext = null;
-  }
-});
-
-// src/ssr/render-keys.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(
-    `${PREPASS_REMOVED_MSG}; async resource plans are not supported`
-  );
-}
-function collectResources(_opts) {
-  throw new Error(`${PREPASS_REMOVED_MSG}; collectResources is disabled`);
-}
-var keyCounter, currentRenderData, PREPASS_REMOVED_MSG, resolveResources;
-var init_render_keys = __esm({
-  "src/ssr/render-keys.ts"() {
-    "use strict";
-    keyCounter = 0;
-    currentRenderData = null;
-    PREPASS_REMOVED_MSG = "SSR collection/prepass is removed: SSR is strictly synchronous";
-    resolveResources = resolvePlan;
-  }
-});
-
 // src/router/match.ts
 function match(path, pattern) {
   const normalizedPath = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
@@ -3034,6 +3114,29 @@ var init_match = __esm({
   }
 });
 
+// src/runtime/execution-model.ts
+function getExecutionModel() {
+  const g = globalThis;
+  return g[EXECUTION_MODEL_KEY];
+}
+function assertExecutionModel(model) {
+  const g = globalThis;
+  const cur = g[EXECUTION_MODEL_KEY];
+  if (cur && cur !== model) {
+    throw new Error(
+      `[Askr] mixing execution models is not allowed (current: ${cur}, attempted: ${model}). Choose exactly one: createSPA, createSSR, or createIslands.`
+    );
+  }
+  if (!cur) g[EXECUTION_MODEL_KEY] = model;
+}
+var EXECUTION_MODEL_KEY;
+var init_execution_model = __esm({
+  "src/runtime/execution-model.ts"() {
+    "use strict";
+    EXECUTION_MODEL_KEY = /* @__PURE__ */ Symbol.for("__ASKR_EXECUTION_MODEL__");
+  }
+});
+
 // src/router/route.ts
 var route_exports = {};
 __export(route_exports, {
@@ -3050,6 +3153,13 @@ __export(route_exports, {
   setServerLocation: () => setServerLocation,
   unloadNamespace: () => unloadNamespace
 });
+function setHasRoutes(value) {
+  try {
+    const g = globalThis;
+    g[HAS_ROUTES_KEY] = value;
+  } catch {
+  }
+}
 function getDepth(path) {
   const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
   return normalized === "/" ? 0 : normalized.split("/").filter(Boolean).length;
@@ -3168,6 +3278,11 @@ function _unlockRouteRegistrationForTests() {
   registrationLocked = false;
 }
 function route(path, handler, namespace) {
+  if (getExecutionModel() === "islands") {
+    throw new Error(
+      "Routes are not supported with islands. Use createSPA (client) or createSSR (server) instead."
+    );
+  }
   if (typeof path === "undefined") {
     const instance = getCurrentComponentInstance();
     if (!instance) {
@@ -3210,7 +3325,7 @@ function route(path, handler, namespace) {
   }
   if (registrationLocked) {
     throw new Error(
-      "Route registration is locked after app startup. Register routes at module load time before calling createIsland()."
+      "Route registration is locked after app startup. Register routes at module load time before calling createSPA or createSSR."
     );
   }
   if (typeof handler !== "function") {
@@ -3220,6 +3335,7 @@ function route(path, handler, namespace) {
   }
   const routeObj = { path, handler, namespace };
   routes.push(routeObj);
+  setHasRoutes(true);
   const depth = getDepth(path);
   let depthRoutes = routesByDepth.get(depth);
   if (!depthRoutes) {
@@ -3243,1373 +3359,303 @@ function unloadNamespace(namespace) {
     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/jsx/utils.ts
-function isElement(value) {
-  return typeof value === "object" && value !== null && value.$$typeof === ELEMENT_TYPE;
-}
-function cloneElement(element, props) {
-  return {
-    ...element,
-    props: { ...element.props, ...props }
-  };
-}
-var init_utils2 = __esm({
-  "src/jsx/utils.ts"() {
-    "use strict";
-    init_types2();
-  }
-});
-
-// src/jsx/index.ts
-var init_jsx = __esm({
-  "src/jsx/index.ts"() {
-    "use strict";
-    init_types2();
-    init_utils2();
-  }
-});
-
-// src/foundations/portal.tsx
-function definePortal() {
-  if (typeof createPortalSlot !== "function") {
-    let HostFallback2 = function() {
-      hosts = hosts.filter((h) => h.mounted !== false);
-      const inst = getCurrentComponentInstance();
-      if (inst && !hosts.includes(inst)) hosts.push(inst);
-      const owner = hosts.find((h) => h.mounted === true) || null;
-      const mountedHosts = hosts.filter((h) => h.mounted === true);
-      if (mountedHosts.length > 1) {
-        logger.warn(
-          "[Portal] multiple hosts are mounted for same portal; first mounted host will be owner"
-        );
-      }
-      if (inst && owner && owner !== inst) {
-        logger.debug(
-          "[Portal] non-owner reader detected; only owner renders portal content"
-        );
-      }
-      if (process.env.NODE_ENV !== "production") {
-        const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
-        ns.__PORTAL_READS = (ns.__PORTAL_READS || 0) + 1;
-      }
-      if (process.env.NODE_ENV !== "production" && inst && owner && inst === owner) {
-        logger.debug("[Portal] owner read ->", inst.id, "pending=", pending);
-        const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
-        ns.__PORTAL_HOST_ATTACHED = !!(inst && inst.target);
-        ns.__PORTAL_HOST_ID = inst ? inst.id : void 0;
-      }
-      return inst === owner ? pending : void 0;
-    };
-    var HostFallback = HostFallback2;
-    let hosts = [];
-    let pending;
-    HostFallback2.render = function RenderFallback(props) {
-      hosts = hosts.filter((h) => h.mounted !== false);
-      const owner = hosts.find((h) => h.mounted === true) || null;
-      if (!owner) {
-        logger.debug(
-          "[Portal] fallback.write dropped -> no owner or not mounted",
-          props?.children
-        );
-        return null;
-      }
-      pending = props.children;
-      logger.debug("[Portal] fallback.write ->", pending, "owner=", owner.id);
-      if (process.env.NODE_ENV !== "production") {
-        const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
-        ns.__PORTAL_WRITES = (ns.__PORTAL_WRITES || 0) + 1;
-      }
-      if (owner && owner.notifyUpdate) {
-        if (process.env.NODE_ENV !== "production")
-          logger.debug(
-            "[Portal] fallback.write notify ->",
-            owner.id,
-            !!owner.notifyUpdate
-          );
-        owner.notifyUpdate();
-      }
-      return null;
-    };
-    return HostFallback2;
-  }
-  const slot = createPortalSlot();
-  function PortalHost() {
-    return slot.read();
-  }
-  PortalHost.render = function PortalRender(props) {
-    logger.debug("[Portal] write ->", props?.children);
-    if (process.env.NODE_ENV !== "production") {
-      const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
-      ns.__PORTAL_WRITES = (ns.__PORTAL_WRITES || 0) + 1;
-    }
-    slot.write(props.children);
-    return null;
-  };
-  return PortalHost;
-}
-function _resetDefaultPortal() {
-  _defaultPortal = void 0;
-  _defaultPortalIsFallback = false;
-}
-function ensureDefaultPortal() {
-  logger.debug(
-    "[DefaultPortal] ensureDefaultPortal _defaultPortalIsFallback=",
-    _defaultPortalIsFallback,
-    "createPortalSlot=",
-    typeof createPortalSlot === "function"
-  );
-  if (!_defaultPortal) {
-    if (typeof createPortalSlot === "function") {
-      _defaultPortal = definePortal();
-      _defaultPortalIsFallback = false;
-      logger.debug("[DefaultPortal] created real portal");
-    } else {
-      _defaultPortal = definePortal();
-      _defaultPortalIsFallback = true;
-      logger.debug("[DefaultPortal] created fallback portal");
-    }
-    return _defaultPortal;
-  }
-  if (_defaultPortalIsFallback && typeof createPortalSlot === "function") {
-    const real = definePortal();
-    _defaultPortal = real;
-    _defaultPortalIsFallback = false;
-  }
-  if (!_defaultPortalIsFallback && typeof createPortalSlot !== "function") {
-    const fallback = definePortal();
-    _defaultPortal = fallback;
-    _defaultPortalIsFallback = true;
-    logger.debug("[DefaultPortal] reverted to fallback portal");
-  }
-  return _defaultPortal;
-}
-var _defaultPortal, _defaultPortalIsFallback, DefaultPortal;
-var init_portal = __esm({
-  "src/foundations/portal.tsx"() {
-    "use strict";
-    init_component();
-    init_logger();
-    _defaultPortalIsFallback = false;
-    DefaultPortal = (() => {
-      function Host() {
-        const v = ensureDefaultPortal()();
-        return v === void 0 ? null : v;
-      }
-      Host.render = function Render(props) {
-        ensureDefaultPortal().render(props);
-        return null;
-      };
-      return Host;
-    })();
-  }
-});
-
-// src/ssr/escape.ts
-function escapeText(text) {
-  const useCache = text.length <= 64;
-  if (useCache) {
-    const cached = escapeCache.get(text);
-    if (cached !== void 0) return cached;
-  }
-  const str = String(text);
-  if (!str.includes("&") && !str.includes("<") && !str.includes(">")) {
-    if (useCache && escapeCache.size < MAX_CACHE_SIZE) {
-      escapeCache.set(text, str);
-    }
-    return str;
-  }
-  const result = str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-  if (useCache && escapeCache.size < MAX_CACHE_SIZE) {
-    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 escapeCssValue(value) {
-  const str = String(value);
-  if (/(?:url|expression|javascript)\s*\(/i.test(str)) {
-    return "";
-  }
-  return str.replace(/[{}<>\\]/g, "");
-}
-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()}`);
-    const safeValue = escapeCssValue(String(v));
-    if (safeValue) {
-      out += `${prop}:${safeValue};`;
-    }
-  }
-  return out;
-}
-var VOID_ELEMENTS, escapeCache, MAX_CACHE_SIZE;
-var init_escape = __esm({
-  "src/ssr/escape.ts"() {
-    "use strict";
-    VOID_ELEMENTS = /* @__PURE__ */ new Set([
-      "area",
-      "base",
-      "br",
-      "col",
-      "embed",
-      "hr",
-      "img",
-      "input",
-      "link",
-      "meta",
-      "param",
-      "source",
-      "track",
-      "wbr"
-    ]);
-    escapeCache = /* @__PURE__ */ new Map();
-    MAX_CACHE_SIZE = 256;
-  }
-});
-
-// src/ssr/attrs.ts
-function renderAttrs(props, opts) {
-  if (!props || typeof props !== "object") {
-    return opts?.returnDangerousHtml ? { attrs: "" } : "";
-  }
-  let result = "";
-  let dangerousHtml;
-  for (const [key, value] of Object.entries(props)) {
-    if (key === "children") continue;
-    if (key === "dangerouslySetInnerHTML") {
-      if (value && typeof value === "object" && "__html" in value) {
-        dangerousHtml = String(value.__html);
-      }
-      continue;
-    }
-    if (key.length >= 3 && key[0] === "o" && key[1] === "n" && key[2] >= "A" && key[2] <= "Z") {
-      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 || 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))}"`;
-    }
-  }
-  if (opts?.returnDangerousHtml) {
-    return { attrs: result, dangerousHtml };
-  }
-  return result;
-}
-var init_attrs = __esm({
-  "src/ssr/attrs.ts"() {
-    "use strict";
-    init_escape();
-  }
-});
-
-// 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/stream-render.ts
-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 isPromiseLike(x) {
-  if (!x || typeof x !== "object") return false;
-  const then = x.then;
-  return typeof then === "function";
-}
-function executeComponent2(type, props, ctx) {
-  const res = type(props ?? {}, { signal: ctx.signal });
-  if (isPromiseLike(res)) {
-    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 === "symbol" && (type === Fragment || String(type) === "Symbol(Fragment)")) {
-    const children = normalizeChildren(node);
-    renderChildrenToSink(children, sink, ctx);
-    return;
-  }
-  if (typeof type === "function") {
-    const out = withSSRContext(
-      ctx,
-      () => executeComponent2(type, props, ctx)
-    );
-    renderNodeToSink(
-      out,
-      sink,
-      ctx
-    );
-    return;
-  }
-  const tag = String(type);
-  const { attrs, dangerousHtml } = renderAttrs(props, {
-    returnDangerousHtml: true
-  });
-  if (VOID_ELEMENTS.has(tag)) {
-    sink.write(`<${tag}${attrs} />`);
-    return;
-  }
-  sink.write(`<${tag}${attrs}>`);
-  if (dangerousHtml !== void 0) {
-    sink.write(dangerousHtml);
-  } else {
-    const children = normalizeChildren(node);
-    renderChildrenToSink(children, sink, ctx);
-  }
-  sink.write(`</${tag}>`);
-}
-var init_stream_render = __esm({
-  "src/ssr/stream-render.ts"() {
-    "use strict";
-    init_jsx();
-    init_context2();
-    init_escape();
-    init_attrs();
-  }
-});
-
-// src/ssr/index.ts
-var ssr_exports = {};
-__export(ssr_exports, {
-  SSRDataMissingError: () => SSRDataMissingError,
-  collectResources: () => collectResources,
-  popSSRStrictPurityGuard: () => popSSRStrictPurityGuard,
-  pushSSRStrictPurityGuard: () => pushSSRStrictPurityGuard,
-  renderToStream: () => renderToStream,
-  renderToString: () => renderToString,
-  renderToStringSync: () => renderToStringSync,
-  renderToStringSyncForUrl: () => renderToStringSyncForUrl,
-  resolvePlan: () => resolvePlan,
-  resolveResources: () => resolveResources
-});
-function pushSSRStrictPurityGuard() {
-  if (process.env.NODE_ENV === "production") return;
-  __ssrGuardStack.push({
-    random: Reflect.get(Math, "random"),
-    now: Reflect.get(Date, "now")
-  });
-  Reflect.set(Math, "random", () => {
-    throw new Error(
-      "SSR Strict Purity: Math.random is not allowed during synchronous SSR. Use the provided `ssr` context RNG instead."
-    );
-  });
-  Reflect.set(Date, "now", () => {
-    throw new Error(
-      "SSR Strict Purity: Date.now is not allowed during synchronous SSR. Pass timestamps explicitly or use deterministic helpers."
-    );
-  });
-}
-function popSSRStrictPurityGuard() {
-  if (process.env.NODE_ENV === "production") return;
-  const prev = __ssrGuardStack.pop();
-  if (prev) {
-    Reflect.set(Math, "random", prev.random);
-    Reflect.set(Date, "now", prev.now);
-  }
-}
-function renderChildSync(child, ctx) {
-  if (typeof child === "string") return escapeText(child);
-  if (typeof child === "number") return escapeText(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 (process.env.NODE_ENV !== "production") {
-    try {
-      logger.warn("[SSR] renderNodeSync type:", typeof type, type);
-    } catch {
-    }
-  }
-  if (typeof type === "function") {
-    const result = executeComponentSync2(type, props, ctx);
-    if (result instanceof Promise) {
-      throwSSRDataMissing();
-    }
-    return renderNodeSync(result, ctx);
-  }
-  if (typeof type === "symbol") {
-    if (type === Fragment) {
-      const childrenArr = Array.isArray(node.children) ? node.children : Array.isArray(props?.children) ? props?.children : void 0;
-      if (process.env.NODE_ENV !== "production") {
-        try {
-          logger.warn("[SSR] fragment children length:", childrenArr?.length);
-        } catch {
-        }
-      }
-      return renderChildrenSync(childrenArr, ctx);
-    }
-    throw new Error(
-      `renderNodeSync: unsupported VNode symbol type: ${String(type)}`
-    );
-  }
-  const typeStr = type;
-  if (VOID_ELEMENTS.has(typeStr)) {
-    const attrs2 = renderAttrs(props);
-    return `<${typeStr}${attrs2} />`;
-  }
-  const { attrs, dangerousHtml } = renderAttrs(props, {
-    returnDangerousHtml: true
-  });
-  if (dangerousHtml !== void 0) {
-    return `<${typeStr}${attrs}>${dangerousHtml}</${typeStr}>`;
-  }
-  const children = node.children;
-  const childrenHtml = renderChildrenSync(children, ctx);
-  return `<${typeStr}${attrs}>${childrenHtml}</${typeStr}>`;
-}
-function executeComponentSync2(component, props, ctx) {
-  try {
-    if (process.env.NODE_ENV !== "production") {
-      pushSSRStrictPurityGuard();
-    }
-    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();
-        }
-        if (typeof result === "string" || typeof result === "number" || typeof result === "boolean" || result === null || result === void 0) {
-          const inner = result === null || result === void 0 || result === false ? "" : String(result);
-          return {
-            $$typeof: ELEMENT_TYPE,
-            type: Fragment,
-            props: { children: inner ? [inner] : [] }
-          };
-        }
-        return result;
-      });
-    } finally {
-      setCurrentComponentInstance(prev);
-    }
-  } finally {
-    if (process.env.NODE_ENV !== "production") popSSRStrictPurityGuard();
-  }
-}
-function renderToStringSync(component, props, options) {
-  const seed = options?.seed ?? 12345;
-  const ctx = createRenderContext(seed);
-  startRenderPhase(options?.data ?? null);
-  try {
-    const wrapped = (p, c) => {
-      const out = component(p ?? {}, c);
-      const portalVNode = {
-        $$typeof: ELEMENT_TYPE,
-        type: DefaultPortal,
-        props: {},
-        key: "__default_portal"
-      };
-      if (out == null) {
-        return {
-          $$typeof: ELEMENT_TYPE,
-          type: Fragment,
-          props: { children: [portalVNode] }
-        };
-      }
-      return {
-        $$typeof: ELEMENT_TYPE,
-        type: Fragment,
-        props: { children: [out, portalVNode] }
-      };
-    };
-    const node = executeComponentSync2(wrapped, props || {}, ctx);
-    if (!node) {
-      throw new Error("renderToStringSync: wrapped component returned empty");
-    }
-    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 wrapped = (p, c) => {
-      const out = resolved.handler(p ?? {}, c);
-      const portalVNode = {
-        $$typeof: ELEMENT_TYPE,
-        type: DefaultPortal,
-        props: {},
-        key: "__default_portal"
-      };
-      if (out == null) {
-        return {
-          $$typeof: ELEMENT_TYPE,
-          type: Fragment,
-          props: { children: [portalVNode] }
-        };
-      }
-      return {
-        $$typeof: ELEMENT_TYPE,
-        type: Fragment,
-        props: { children: [out, portalVNode] }
-      };
-    };
-    const node = executeComponentSync2(wrapped, 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 = 12345, 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 __ssrGuardStack;
-var init_ssr = __esm({
-  "src/ssr/index.ts"() {
-    "use strict";
-    init_route();
-    init_jsx();
-    init_portal();
-    init_context2();
-    init_component();
-    init_escape();
-    init_attrs();
-    init_logger();
-    init_context2();
-    init_sink();
-    init_stream_render();
-    init_render_keys();
-    __ssrGuardStack = [];
-  }
-});
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  DefaultPortal: () => DefaultPortal,
-  Fragment: () => Fragment2,
-  Link: () => Link,
-  Slot: () => Slot,
-  _resetDefaultPortal: () => _resetDefaultPortal,
-  cleanupApp: () => cleanupApp,
-  clearRoutes: () => clearRoutes,
-  collectResources: () => collectResources,
-  createIsland: () => createIsland,
-  createSPA: () => createSPA,
-  defineContext: () => defineContext,
-  definePortal: () => definePortal,
-  derive: () => derive,
-  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,
-  task: () => task,
-  unloadNamespace: () => unloadNamespace
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/runtime/state.ts
-init_scheduler();
-init_component();
-init_invariant();
-init_fastlane_shared();
-function state(initialValue) {
-  const instance = getCurrentInstance();
-  if (!instance) {
-    throw new Error(
-      "state() can only be called during component render execution. Move state() calls to the top level of your component function."
-    );
-  }
-  const index = getNextStateIndex();
-  const stateValues = instance.stateValues;
-  if (index < instance.stateIndexCheck) {
-    throw new Error(
-      `State index violation: state() call at index ${index}, but previously saw index ${instance.stateIndexCheck}. This happens when state() is called conditionally (inside if/for/etc). Move all state() calls to the top level of your component function, before any conditionals.`
-    );
-  }
-  invariant(
-    index >= instance.stateIndexCheck,
-    "[State] State indices must increase monotonically"
-  );
-  instance.stateIndexCheck = index;
-  if (instance.firstRenderComplete) {
-    if (!instance.expectedStateIndices.includes(index)) {
-      throw new Error(
-        `Hook order violation: state() called at index ${index}, but this index was not in the first render's sequence [${instance.expectedStateIndices.join(", ")}]. This usually means state() is inside a conditional or loop. Move all state() calls to the top level of your component function.`
-      );
-    }
-  } else {
-    instance.expectedStateIndices.push(index);
-  }
-  if (stateValues[index]) {
-    const existing = stateValues[index];
-    if (existing._owner !== instance) {
-      throw new Error(
-        `State ownership violation: state() called at index ${index} is owned by a different component instance. State ownership is positional and immutable.`
-      );
-    }
-    return existing;
-  }
-  const cell = createStateCell(initialValue, instance);
-  stateValues[index] = cell;
-  return cell;
-}
-function createStateCell(initialValue, instance) {
-  let value = initialValue;
-  const readers = /* @__PURE__ */ new Map();
-  function read() {
-    read._hasBeenRead = true;
-    const inst = getCurrentInstance();
-    if (inst && inst._currentRenderToken !== void 0) {
-      if (!inst._pendingReadStates) inst._pendingReadStates = /* @__PURE__ */ new Set();
-      inst._pendingReadStates.add(read);
-    }
-    return value;
-  }
-  read._readers = readers;
-  read._owner = instance;
-  read.set = (newValueOrUpdater) => {
-    const currentInst = getCurrentInstance();
-    if (currentInst !== null && 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") {
-      if (typeof console !== "undefined" && console.warn) {
-        console.warn(
-          "[Askr] state.set() called during render - update skipped. Move state updates to event handlers."
-        );
-      }
-      return;
-    }
-    let newValue;
-    if (typeof newValueOrUpdater === "function") {
-      const updater = newValueOrUpdater;
-      newValue = updater(value);
-    } else {
-      newValue = newValueOrUpdater;
-    }
-    if (Object.is(value, newValue)) return;
-    if (isBulkCommitActive2()) {
-      value = newValue;
-      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 task2 = instance._pendingFlushTask;
-      if (task2) globalScheduler.enqueue(task2);
-      else
-        globalScheduler.enqueue(() => {
-          instance.hasPendingUpdate = false;
-          instance.notifyUpdate?.();
-        });
+      const depth = getDepth(removed.path);
+      const depthRoutes = routesByDepth.get(depth);
+      if (depthRoutes) {
+        const idx = depthRoutes.indexOf(removed);
+        if (idx >= 0) {
+          depthRoutes.splice(idx, 1);
+        }
+      }
     }
-  };
-  return read;
+  }
+  namespaces.delete(namespace);
+  return before - routes.length;
 }
-
-// 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()
+function clearRoutes() {
+  routes.length = 0;
+  namespaces.clear();
+  routesByDepth.clear();
+  registrationLocked = false;
+  setHasRoutes(false);
+}
+function normalizeHandler(handler) {
+  if (handler == null) return void 0;
+  if (typeof handler === "function") {
+    return (params, ctx) => {
+      try {
+        return handler(params, ctx);
+      } catch {
+        return handler(params);
+      }
     };
   }
-  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 })
+  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."
       );
-    } 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 {
-        if (this.ownerName) {
-          logger.error(
-            `[Askr] Async resource error in ${this.ownerName}:`,
-            err
+    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."
           );
-        } else {
-          logger.error("[Askr] Async resource error:", err);
         }
-      } catch {
+        if (childNormalized) route(childPath, childNormalized);
       }
-      this.notifySubscribers();
-    });
+      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
+        });
+      }
+    }
   }
-  refresh() {
-    this.generation++;
-    this.controller?.abort();
-    this.start();
+  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
+      });
+    }
   }
-  abort() {
-    this.controller?.abort();
+  candidates.sort((a, b) => b.specificity - a.specificity);
+  if (candidates.length > 0) {
+    const best = candidates[0];
+    return { handler: best.route.handler, params: best.params };
   }
-};
+  return null;
+}
+var routes, namespaces, HAS_ROUTES_KEY, routesByDepth, serverLocation, registrationLocked;
+var init_route = __esm({
+  "src/router/route.ts"() {
+    "use strict";
+    init_match();
+    init_component();
+    init_execution_model();
+    routes = [];
+    namespaces = /* @__PURE__ */ new Set();
+    HAS_ROUTES_KEY = /* @__PURE__ */ Symbol.for("__ASKR_HAS_ROUTES__");
+    setHasRoutes(false);
+    routesByDepth = /* @__PURE__ */ new Map();
+    serverLocation = null;
+    registrationLocked = false;
+  }
+});
 
-// src/shared/derive-cache.ts
-var deriveCacheMap = /* @__PURE__ */ new WeakMap();
-function getDeriveCache(instance) {
-  let cache = deriveCacheMap.get(instance);
-  if (!cache) {
-    cache = /* @__PURE__ */ new Map();
-    deriveCacheMap.set(instance, cache);
+// src/router/navigate.ts
+function registerAppInstance(instance, _path) {
+  currentInstance2 = instance;
+  if (process.env.NODE_ENV === "production") {
+    lockRouteRegistration();
+  }
+}
+function handlePopState(_event) {
+  const path = window.location.pathname;
+  if (!currentInstance2) {
+    return;
+  }
+  const resolved = resolveRoute(path);
+  if (resolved) {
+    cleanupComponent(currentInstance2);
+    currentInstance2.fn = resolved.handler;
+    currentInstance2.props = resolved.params;
+    currentInstance2.stateValues = [];
+    currentInstance2.expectedStateIndices = [];
+    currentInstance2.firstRenderComplete = false;
+    currentInstance2.stateIndexCheck = -1;
+    currentInstance2.evaluationGeneration++;
+    currentInstance2.notifyUpdate = null;
+    currentInstance2.abortController = new AbortController();
+    mountComponent(currentInstance2);
+  }
+}
+function initializeNavigation() {
+  if (typeof window !== "undefined") {
+    window.addEventListener("popstate", handlePopState);
   }
-  return cache;
 }
+var currentInstance2;
+var init_navigate = __esm({
+  "src/router/navigate.ts"() {
+    "use strict";
+    init_route();
+    init_component();
+    currentInstance2 = null;
+  }
+});
 
-// src/runtime/operations.ts
-init_context2();
-init_render_keys();
-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: () => {
-      }
-    };
+// src/jsx/index.ts
+var init_jsx2 = __esm({
+  "src/jsx/index.ts"() {
+    "use strict";
+    init_types2();
   }
-  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: () => {
+});
+
+// src/foundations/portal.tsx
+function definePortal() {
+  if (typeof createPortalSlot !== "function") {
+    let HostFallback2 = function() {
+      if (owner && owner.mounted === false) {
+        owner = null;
+        pending = void 0;
       }
-    }
-  });
-  const h = holder();
-  if (!h.cell) {
-    const frame = getCurrentContextFrame();
-    const cell2 = new ResourceCell(fn, deps, frame);
-    cell2.ownerName = inst.fn?.name || "<anonymous>";
-    h.cell = cell2;
-    h.snapshot = cell2.snapshot;
-    const unsubscribe = cell2.subscribe(() => {
-      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 {
+      const inst = getCurrentComponentInstance();
+      if (!owner && inst) owner = inst;
+      if (process.env.NODE_ENV !== "production") {
+        const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
+        ns.__PORTAL_READS = (ns.__PORTAL_READS || 0) + 1;
       }
-    });
-    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;
+      if (process.env.NODE_ENV !== "production") {
+        if (inst && owner && inst !== owner && inst.mounted === true) {
+          logger.warn(
+            "[Portal] multiple mounted hosts detected; first mounted host is owner"
+          );
+        }
       }
-    } 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;
+      return inst && owner && inst === owner ? pending : void 0;
+    };
+    var HostFallback = HostFallback2;
+    let owner = null;
+    let pending;
+    HostFallback2.render = function RenderFallback(props) {
+      if (!owner || owner.mounted !== true) return null;
+      if (process.env.NODE_ENV !== "production") {
+        const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
+        ns.__PORTAL_WRITES = (ns.__PORTAL_WRITES || 0) + 1;
       }
-    } 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;
-    }
+      pending = props.children;
+      if (owner.notifyUpdate) owner.notifyUpdate();
+      return null;
+    };
+    return HostFallback2;
+  }
+  const slot = createPortalSlot();
+  function PortalHost() {
+    return slot.read();
   }
-  return h.snapshot;
+  PortalHost.render = function PortalRender(props) {
+    if (process.env.NODE_ENV !== "production") {
+      const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
+      ns.__PORTAL_WRITES = (ns.__PORTAL_WRITES || 0) + 1;
+    }
+    slot.write(props.children);
+    return null;
+  };
+  return PortalHost;
 }
-function derive(source, map) {
-  if (map === void 0 && typeof source === "function") {
-    const value2 = source();
-    if (value2 == null) return null;
-    const instance2 = getCurrentComponentInstance();
-    if (!instance2) {
-      return value2;
+function ensureDefaultPortal() {
+  if (!_defaultPortal) {
+    if (typeof createPortalSlot === "function") {
+      _defaultPortal = definePortal();
+      _defaultPortalIsFallback = false;
+    } else {
+      _defaultPortal = definePortal();
+      _defaultPortalIsFallback = true;
     }
-    const cache2 = getDeriveCache(instance2);
-    if (cache2.has(value2)) return cache2.get(value2);
-    cache2.set(value2, value2);
-    return value2;
-  }
-  let value;
-  if (typeof source === "function" && !("value" in source)) {
-    value = source();
-  } else {
-    value = source?.value ?? source;
+    return _defaultPortal;
   }
-  if (value == null) return null;
-  const instance = getCurrentComponentInstance();
-  if (!instance) {
-    return map(value);
+  if (_defaultPortalIsFallback && typeof createPortalSlot === "function") {
+    const real = definePortal();
+    _defaultPortal = real;
+    _defaultPortalIsFallback = false;
   }
-  const cache = getDeriveCache(instance);
-  if (cache.has(value)) {
-    return cache.get(value);
+  if (!_defaultPortalIsFallback && typeof createPortalSlot !== "function") {
+    const fallback = definePortal();
+    _defaultPortal = fallback;
+    _defaultPortalIsFallback = true;
   }
-  const result = map(value);
-  cache.set(value, result);
-  return result;
-}
-function task(fn) {
-  const ownerIsRoot = getCurrentComponentInstance()?.isRoot ?? false;
-  registerMountOperation(async () => {
-    if (!ownerIsRoot) {
-      throw new Error("[Askr] task() may only be used in root components");
-    }
-    return await fn();
-  });
+  return _defaultPortal;
 }
+var _defaultPortal, _defaultPortalIsFallback, DefaultPortal;
+var init_portal = __esm({
+  "src/foundations/portal.tsx"() {
+    "use strict";
+    init_component();
+    init_logger();
+    _defaultPortalIsFallback = false;
+    DefaultPortal = (() => {
+      function Host() {
+        const v = ensureDefaultPortal()();
+        return v === void 0 ? null : v;
+      }
+      Host.render = function Render(props) {
+        ensureDefaultPortal().render(props);
+        return null;
+      };
+      return Host;
+    })();
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createIsland: () => createIsland,
+  createSPA: () => createSPA,
+  derive: () => derive,
+  state: () => state
+});
+module.exports = __toCommonJS(index_exports);
 
 // src/boot/index.ts
 init_component();
 init_scheduler();
 init_logger();
 init_navigate();
-init_jsx();
+init_execution_model();
+init_jsx2();
 init_portal();
 init_renderer();
+var HAS_ROUTES_KEY2 = /* @__PURE__ */ Symbol.for("__ASKR_HAS_ROUTES__");
 var componentIdCounter = 0;
 var instancesByRoot = /* @__PURE__ */ new WeakMap();
 var CLEANUP_SYMBOL = /* @__PURE__ */ Symbol.for("__tempoCleanup__");
@@ -4749,6 +3795,7 @@ function mountOrUpdate(rootElement, componentFn, options) {
   globalScheduler.flush();
 }
 function createIsland(config) {
+  assertExecutionModel("islands");
   if (!config || typeof config !== "object") {
     throw new Error("createIsland requires a config object");
   }
@@ -4759,433 +3806,230 @@ function createIsland(config) {
   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, {
-    cleanupStrict: config.cleanupStrict
-  });
-}
-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: [] }), {
-      cleanupStrict: false
-    });
-    const instance2 = instancesByRoot.get(rootElement);
-    if (!instance2) throw new Error("Internal error: app instance missing");
-    registerAppInstance(instance2, path);
-    initializeNavigation();
-    return;
-  }
-  mountOrUpdate(rootElement, resolved.handler, {
-    cleanupStrict: false
-  });
-  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, {
-    cleanupStrict: false
-  });
-  const { registerAppInstance: registerAppInstance2, initializeNavigation: initializeNavigation2 } = await Promise.resolve().then(() => (init_navigate(), navigate_exports));
-  const instance = instancesByRoot.get(rootElement);
-  if (!instance) throw new Error("Internal error: app instance missing");
-  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();
-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/foundations/layout.tsx
-function layout(Layout) {
-  return (children, props) => Layout({ ...props, children });
-}
-
-// src/foundations/slot.tsx
-init_logger();
-init_jsx();
-function Slot(props) {
-  if (props.asChild) {
-    const { children, ...rest } = props;
-    if (isElement(children)) {
-      return cloneElement(children, rest);
-    }
-    logger.warn("<Slot asChild> expects a single JSX element child.");
-    return null;
-  }
-  return {
-    $$typeof: ELEMENT_TYPE,
-    type: Fragment,
-    props: { children: props.children }
-  };
-}
-
-// src/index.ts
-init_portal();
-init_ssr();
-init_jsx_runtime();
-init_route();
-init_navigate();
-
-// src/runtime/fastlane.ts
-init_scheduler();
-init_logger();
-init_component();
-init_renderer();
-init_fastlane_shared();
-init_types2();
-init_dev_namespace();
-function unwrapFragmentForFastPath(vnode) {
-  if (!vnode || typeof vnode !== "object" || !("type" in vnode)) return vnode;
-  const v = vnode;
-  if (typeof v.type === "symbol" && (v.type === Fragment || String(v.type) === "Symbol(askr.fragment)")) {
-    const children = v.children || v.props?.children;
-    if (Array.isArray(children) && children.length > 0) {
-      for (const child of children) {
-        if (child && typeof child === "object" && "type" in child) {
-          const c = child;
-          if (typeof c.type === "string") {
-            return child;
-          }
-        }
-      }
-    }
-  }
-  return vnode;
-}
-function classifyUpdate(instance, result) {
-  const unwrappedResult = unwrapFragmentForFastPath(result);
-  if (!unwrappedResult || typeof unwrappedResult !== "object" || !("type" in unwrappedResult))
-    return { useFastPath: false, reason: "not-vnode" };
-  const vnode = unwrappedResult;
-  if (vnode == null || typeof vnode.type !== "string")
-    return { useFastPath: false, reason: "not-intrinsic" };
-  const parent = instance.target;
-  if (!parent) return { useFastPath: false, reason: "no-root" };
-  const firstChild = parent.children[0];
-  if (!firstChild) return { useFastPath: false, reason: "no-first-child" };
-  if (firstChild.tagName.toLowerCase() !== String(vnode.type).toLowerCase())
-    return { useFastPath: false, reason: "root-tag-mismatch" };
-  const children = vnode.children || vnode.props?.children;
-  if (!Array.isArray(children))
-    return { useFastPath: false, reason: "no-children-array" };
-  for (const c of children) {
-    if (typeof c === "object" && c !== null && "type" in c && typeof c.type === "function") {
-      return { useFastPath: false, reason: "component-child-present" };
-    }
-  }
-  if (instance.mountOperations.length > 0)
-    return { useFastPath: false, reason: "pending-mounts" };
-  try {
-    populateKeyMapForElement(firstChild);
-  } catch {
-  }
-  const oldKeyMap = getKeyMapForElement(firstChild);
-  const decision = isKeyedReorderFastPathEligible(
-    firstChild,
-    children,
-    oldKeyMap
-  );
-  if (!decision.useFastPath || decision.totalKeyed < 128)
-    return { ...decision, useFastPath: false, reason: "renderer-declined" };
-  return { ...decision, useFastPath: true };
-}
-function commitReorderOnly(instance, result) {
-  const evaluate2 = globalThis.__ASKR_RENDERER?.evaluate;
-  if (typeof evaluate2 !== "function") {
-    logger.warn(
-      "[Tempo][FASTPATH][DEV] renderer.evaluate not available; declining fast-lane"
-    );
-    return false;
-  }
-  const schedBefore = process.env.NODE_ENV !== "production" ? globalScheduler.getState() : null;
-  enterBulkCommit();
-  try {
-    globalScheduler.runWithSyncProgress(() => {
-      evaluate2(result, instance.target);
-      try {
-        finalizeReadSubscriptions(instance);
-      } catch (e) {
-        if (process.env.NODE_ENV !== "production") throw e;
-      }
-    });
-    const clearedAfter = globalScheduler.clearPendingSyncTasks?.() ?? 0;
-    setDevValue("__FASTLANE_CLEARED_AFTER", clearedAfter);
-    if (process.env.NODE_ENV !== "production") {
-      validateFastLaneInvariants(instance, schedBefore);
-    }
-    return true;
-  } finally {
-    exitBulkCommit();
+      "createIsland does not accept routes; use createSPA for routed apps"
+    );
   }
-  if (process.env.NODE_ENV !== "production") {
-    if (isBulkCommitActive2()) {
+  try {
+    const g = globalThis;
+    if (g[HAS_ROUTES_KEY2]) {
       throw new Error(
-        "Fast-lane invariant violated: bulk commit flag still set after commit"
+        "Routes are not supported with islands. Use createSPA (client) or createSSR (server) instead."
       );
     }
+  } catch {
   }
+  mountOrUpdate(rootElement, config.component, {
+    cleanupStrict: config.cleanupStrict
+  });
 }
-function validateFastLaneInvariants(instance, schedBefore) {
-  const commitCount = getDevValue("__LAST_FASTPATH_COMMIT_COUNT") ?? 0;
-  const invariants = {
-    commitCount,
-    mountOps: instance.mountOperations.length,
-    cleanupFns: instance.cleanupFns.length
-  };
-  setDevValue("__LAST_FASTLANE_INVARIANTS", invariants);
-  if (commitCount !== 1) {
-    console.error(
-      "[FASTLANE][INV] commitCount",
-      commitCount,
-      "diag",
-      globalThis.__ASKR_DIAG
-    );
-    throw new Error(
-      "Fast-lane invariant violated: expected exactly one DOM commit during reorder-only commit"
-    );
+async function createSPA(config) {
+  assertExecutionModel("spa");
+  if (!config || typeof config !== "object") {
+    throw new Error("createSPA requires a config object");
   }
-  if (invariants.mountOps > 0) {
+  if (!Array.isArray(config.routes) || config.routes.length === 0) {
     throw new Error(
-      "Fast-lane invariant violated: mount operations were registered during bulk commit"
+      "createSPA requires a route table. If you are enhancing existing HTML, use createIsland instead."
     );
   }
-  if (invariants.cleanupFns > 0) {
+  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: [] }), {
+      cleanupStrict: false
+    });
+    const instance2 = instancesByRoot.get(rootElement);
+    if (!instance2) throw new Error("Internal error: app instance missing");
+    registerAppInstance(instance2, path);
+    initializeNavigation();
+    return;
+  }
+  mountOrUpdate(rootElement, resolved.handler, {
+    cleanupStrict: false
+  });
+  const instance = instancesByRoot.get(rootElement);
+  if (!instance) throw new Error("Internal error: app instance missing");
+  registerAppInstance(instance, path);
+  initializeNavigation();
+}
+
+// src/runtime/state.ts
+init_scheduler();
+init_component();
+init_invariant();
+init_fastlane();
+function state(initialValue) {
+  const instance = getCurrentInstance();
+  if (!instance) {
     throw new Error(
-      "Fast-lane invariant violated: cleanup functions were added during bulk commit"
+      "state() can only be called during component render execution. Move state() calls to the top level of your component function."
     );
   }
-  const schedAfter = globalScheduler.getState();
-  if (schedBefore && schedAfter && schedAfter.taskCount > schedBefore.taskCount) {
-    console.error(
-      "[FASTLANE] schedBefore, schedAfter",
-      schedBefore,
-      schedAfter
-    );
-    console.error("[FASTLANE] enqueue logs", getDevValue("__ENQUEUE_LOGS"));
+  const index = getNextStateIndex();
+  const stateValues = instance.stateValues;
+  if (index < instance.stateIndexCheck) {
     throw new Error(
-      "Fast-lane invariant violated: scheduler enqueued leftover work during bulk commit"
+      `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.`
     );
   }
-  let finalState = globalScheduler.getState();
-  const executing = globalScheduler.isExecuting();
-  let outstandingAfter = Math.max(
-    0,
-    finalState.taskCount - (executing ? 1 : 0)
+  invariant(
+    index >= instance.stateIndexCheck,
+    "[State] State indices must increase monotonically"
   );
-  if (outstandingAfter !== 0) {
-    let attempts = 0;
-    while (attempts < 5) {
-      const cleared = globalScheduler.clearPendingSyncTasks?.() ?? 0;
-      if (cleared === 0) break;
-      attempts++;
-    }
-    finalState = globalScheduler.getState();
-    outstandingAfter = Math.max(
-      0,
-      finalState.taskCount - (globalScheduler.isExecuting() ? 1 : 0)
-    );
-    if (outstandingAfter !== 0) {
-      console.error(
-        "[FASTLANE] Post-commit enqueue logs:",
-        getDevValue("__ENQUEUE_LOGS")
-      );
-      console.error(
-        "[FASTLANE] Cleared counts:",
-        getDevValue("__FASTLANE_CLEARED_TASKS"),
-        getDevValue("__FASTLANE_CLEARED_AFTER")
+  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(
-        `Fast-lane invariant violated: scheduler has ${finalState.taskCount} pending task(s) after commit`
+        `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 tryRuntimeFastLaneSync(instance, result) {
-  const cls = classifyUpdate(instance, result);
-  if (!cls.useFastPath) {
-    setDevValue("__LAST_FASTPATH_STATS", void 0);
-    setDevValue("__LAST_FASTPATH_COMMIT_COUNT", 0);
-    return false;
-  }
-  try {
-    return commitReorderOnly(instance, result);
-  } catch (err) {
-    if (process.env.NODE_ENV !== "production") throw err;
-    return false;
+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;
   }
-}
-if (typeof globalThis !== "undefined") {
-  globalThis.__ASKR_FASTLANE = {
-    isBulkCommitActive: isBulkCommitActive2,
-    enterBulkCommit,
-    exitBulkCommit,
-    tryRuntimeFastLaneSync,
-    markFastPathApplied,
-    isFastPathApplied
+  read._readers = readers;
+  read._owner = instance;
+  read.set = (newValueOrUpdater) => {
+    const currentInst = getCurrentInstance();
+    if (currentInst !== null) {
+      throw new Error(
+        `[Askr] state.set() cannot be called during component render. State mutations during render break the actor model and cause infinite loops. Move state updates to event handlers or use conditional rendering instead.`
+      );
+    }
+    let newValue;
+    if (typeof newValueOrUpdater === "function") {
+      const updater = newValueOrUpdater;
+      newValue = updater(value);
+    } else {
+      newValue = newValueOrUpdater;
+    }
+    if (Object.is(value, newValue)) return;
+    if (isBulkCommitActive2()) {
+      value = newValue;
+      return;
+    }
+    value = newValue;
+    const readersMap = read._readers;
+    if (readersMap) {
+      for (const [subInst, token] of readersMap) {
+        if (subInst.lastRenderToken !== token) continue;
+        if (!subInst.hasPendingUpdate) {
+          subInst.hasPendingUpdate = true;
+          const subTask = subInst._pendingFlushTask;
+          if (subTask) globalScheduler.enqueue(subTask);
+          else
+            globalScheduler.enqueue(() => {
+              subInst.hasPendingUpdate = false;
+              subInst.notifyUpdate?.();
+            });
+        }
+      }
+    }
+    const readersMapForOwner = readersMap;
+    const ownerRecordedToken = readersMapForOwner?.get(instance);
+    const ownerShouldEnqueue = (
+      // Normal case: owner read this state in last committed render
+      ownerRecordedToken !== void 0 && instance.lastRenderToken === ownerRecordedToken
+    );
+    if (ownerShouldEnqueue && !instance.hasPendingUpdate) {
+      instance.hasPendingUpdate = true;
+      const task = instance._pendingFlushTask;
+      if (task) globalScheduler.enqueue(task);
+      else
+        globalScheduler.enqueue(() => {
+          instance.hasPendingUpdate = false;
+          instance.notifyUpdate?.();
+        });
+    }
   };
+  return read;
 }
 
-// src/index.ts
-if (typeof globalThis !== "undefined") {
-  const g = globalThis;
-  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;
+// src/runtime/derive.ts
+init_component();
+var deriveCaches = /* @__PURE__ */ new WeakMap();
+function getDeriveCache(instance) {
+  let cache = deriveCaches.get(instance);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    deriveCaches.set(instance, cache);
+  }
+  return cache;
+}
+function derive(source, map) {
+  if (map === void 0 && typeof source === "function") {
+    const value2 = source();
+    if (value2 == null) return null;
+    const instance2 = getCurrentComponentInstance();
+    if (!instance2) {
+      return value2;
+    }
+    const cache2 = getDeriveCache(instance2);
+    if (cache2.has(value2)) return cache2.get(value2);
+    cache2.set(value2, value2);
+    return value2;
+  }
+  let value;
+  if (typeof source === "function" && !("value" in source)) {
+    value = source();
+  } else {
+    value = source?.value ?? source;
+  }
+  if (value == null) return null;
+  const instance = getCurrentComponentInstance();
+  if (!instance) {
+    return map(value);
+  }
+  const cache = getDeriveCache(instance);
+  if (cache.has(value)) {
+    return cache.get(value);
+  }
+  const result = map(value);
+  cache.set(value, result);
+  return result;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  DefaultPortal,
-  Fragment,
-  Link,
-  Slot,
-  _resetDefaultPortal,
-  cleanupApp,
-  clearRoutes,
-  collectResources,
   createIsland,
   createSPA,
-  defineContext,
-  definePortal,
   derive,
-  getLoadedNamespaces,
-  getNamespaceRoutes,
-  getRoutes,
-  getSignal,
-  hasApp,
-  hydrateSPA,
-  jsx,
-  jsxs,
-  layout,
-  navigate,
-  readContext,
-  renderToStream,
-  renderToString,
-  renderToStringSync,
-  renderToStringSyncForUrl,
-  resolveResources,
-  resource,
-  route,
-  scheduleEventHandler,
-  setServerLocation,
-  state,
-  task,
-  unloadNamespace
+  state
 });
 //# sourceMappingURL=index.cjs.map