@askrjs/askr 0.0.3 → 0.0.5

package/dist/{index.cjs → ssr.js}

@@ -1,40 +1,69 @@
-"use strict";
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+
+// src/router/route.ts
+var route_exports = {};
+__export(route_exports, {
+  _lockRouteRegistrationForTests: () => _lockRouteRegistrationForTests,
+  _unlockRouteRegistrationForTests: () => _unlockRouteRegistrationForTests,
+  clearRoutes: () => clearRoutes,
+  getLoadedNamespaces: () => getLoadedNamespaces,
+  getNamespaceRoutes: () => getNamespaceRoutes,
+  getRoutes: () => getRoutes,
+  lockRouteRegistration: () => lockRouteRegistration,
+  registerRoute: () => registerRoute,
+  resolveRoute: () => resolveRoute,
+  route: () => route,
+  setServerLocation: () => setServerLocation,
+  unloadNamespace: () => unloadNamespace
+});
+
+// src/router/match.ts
+function match(path, pattern) {
+  const normalizedPath = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
+  const normalizedPattern = pattern.endsWith("/") && pattern !== "/" ? pattern.slice(0, -1) : pattern;
+  const pathSegments = normalizedPath.split("/").filter(Boolean);
+  const patternSegments = normalizedPattern.split("/").filter(Boolean);
+  if (patternSegments.length === 1 && patternSegments[0] === "*") {
+    return {
+      matched: true,
+      params: {
+        "*": pathSegments.length > 1 ? normalizedPath : pathSegments[0]
+      }
+    };
   }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  if (pathSegments.length !== patternSegments.length) {
+    return { matched: false, params: {} };
+  }
+  const params = {};
+  for (let i = 0; i < patternSegments.length; i++) {
+    const patternSegment = patternSegments[i];
+    const pathSegment = pathSegments[i];
+    if (patternSegment.startsWith("{") && patternSegment.endsWith("}")) {
+      const paramName = patternSegment.slice(1, -1);
+      params[paramName] = decodeURIComponent(pathSegment);
+    } else if (patternSegment === "*") {
+      params["*"] = pathSegment;
+    } else if (patternSegment !== pathSegment) {
+      return { matched: false, params: {} };
+    }
+  }
+  return { matched: true, params };
+}
 
 // src/dev/invariant.ts
 function invariant(condition, message, context) {
   if (!condition) {
-    const contextStr = context ? "\n" + JSON.stringify(context, null, 2) : "";
+    const contextStr = "";
     throw new Error(`[Askr Invariant] ${message}${contextStr}`);
   }
 }
 function assertSchedulingPrecondition(condition, violationMessage) {
   invariant(condition, `[Scheduler Precondition] ${violationMessage}`);
 }
-var init_invariant = __esm({
-  "src/dev/invariant.ts"() {
-    "use strict";
-  }
-});
 
 // src/dev/logger.ts
 function callConsole(method, args) {
@@ -48,322 +77,279 @@ function callConsole(method, args) {
     }
   }
 }
-var logger;
-var init_logger = __esm({
-  "src/dev/logger.ts"() {
-    "use strict";
-    logger = {
-      debug: (...args) => {
-        if (process.env.NODE_ENV === "production") return;
-        callConsole("debug", args);
-      },
-      info: (...args) => {
-        if (process.env.NODE_ENV === "production") return;
-        callConsole("info", args);
-      },
-      warn: (...args) => {
-        if (process.env.NODE_ENV === "production") return;
-        callConsole("warn", args);
-      },
-      error: (...args) => {
-        callConsole("error", args);
-      }
-    };
+var logger = {
+  debug: (...args) => {
+    if (process.env.NODE_ENV === "production") return;
+    callConsole("debug", args);
+  },
+  info: (...args) => {
+    if (process.env.NODE_ENV === "production") return;
+    callConsole("info", args);
+  },
+  warn: (...args) => {
+    if (process.env.NODE_ENV === "production") return;
+    callConsole("warn", args);
+  },
+  error: (...args) => {
+    callConsole("error", args);
   }
-});
+};
 
 // src/runtime/scheduler.ts
+var MAX_FLUSH_DEPTH = 50;
 function isBulkCommitActive() {
   try {
     const fb = globalThis.__ASKR_FASTLANE;
     return typeof fb?.isBulkCommitActive === "function" ? !!fb.isBulkCommitActive() : false;
   } catch (e) {
-    void e;
     return false;
   }
 }
-function isSchedulerExecuting() {
-  return globalScheduler.isExecuting();
-}
-function scheduleEventHandler(handler) {
-  return (event) => {
-    globalScheduler.setInHandler(true);
-    try {
-      handler.call(null, event);
-    } catch (error) {
-      logger.error("[Askr] Event handler error:", error);
-    } finally {
-      globalScheduler.setInHandler(false);
-      const state2 = globalScheduler.getState();
-      if ((state2.queueLength ?? 0) > 0 && !state2.running) {
-        queueMicrotask(() => {
-          try {
-            if (!globalScheduler.isExecuting()) globalScheduler.flush();
-          } catch (err) {
-            setTimeout(() => {
-              throw err;
-            });
-          }
-        });
+var Scheduler = class {
+  constructor() {
+    this.q = [];
+    this.head = 0;
+    this.running = false;
+    this.inHandler = false;
+    this.depth = 0;
+    this.executionDepth = 0;
+    // for compat with existing diagnostics
+    // Monotonic flush version increments at end of each flush
+    this.flushVersion = 0;
+    // Best-effort microtask kick scheduling
+    this.kickScheduled = false;
+    // Escape hatch flag for runWithSyncProgress
+    this.allowSyncProgress = false;
+    // Waiters waiting for flushVersion >= target
+    this.waiters = [];
+    // Keep a lightweight taskCount for compatibility/diagnostics
+    this.taskCount = 0;
+  }
+  enqueue(task) {
+    assertSchedulingPrecondition(
+      typeof task === "function",
+      "enqueue() requires a function"
+    );
+    if (isBulkCommitActive() && !this.allowSyncProgress) {
+      if (process.env.NODE_ENV !== "production") {
+        throw new Error(
+          "[Scheduler] enqueue() during bulk commit (not allowed)"
+        );
       }
+      return;
     }
-  };
-}
-var MAX_FLUSH_DEPTH, Scheduler, globalScheduler;
-var init_scheduler = __esm({
-  "src/runtime/scheduler.ts"() {
-    "use strict";
-    init_invariant();
-    init_logger();
-    MAX_FLUSH_DEPTH = 50;
-    Scheduler = class {
-      constructor() {
-        this.q = [];
-        this.head = 0;
-        this.running = false;
-        this.inHandler = false;
-        this.depth = 0;
-        this.executionDepth = 0;
-        // for compat with existing diagnostics
-        // Monotonic flush version increments at end of each flush
-        this.flushVersion = 0;
-        // Best-effort microtask kick scheduling
+    this.q.push(task);
+    this.taskCount++;
+    if (!this.running && !this.kickScheduled && !this.inHandler && !isBulkCommitActive()) {
+      this.kickScheduled = true;
+      queueMicrotask(() => {
         this.kickScheduled = false;
-        // Escape hatch flag for runWithSyncProgress
-        this.allowSyncProgress = false;
-        // Waiters waiting for flushVersion >= target
-        this.waiters = [];
-        // Keep a lightweight taskCount for compatibility/diagnostics
-        this.taskCount = 0;
-      }
-      enqueue(task2) {
-        assertSchedulingPrecondition(
-          typeof task2 === "function",
-          "enqueue() requires a function"
-        );
-        if (isBulkCommitActive() && !this.allowSyncProgress) {
-          if (process.env.NODE_ENV !== "production") {
-            throw new Error(
-              "[Scheduler] enqueue() during bulk commit (not allowed)"
-            );
-          }
-          return;
-        }
-        this.q.push(task2);
-        this.taskCount++;
-        if (!this.running && !this.kickScheduled && !this.inHandler && !isBulkCommitActive()) {
-          this.kickScheduled = true;
-          queueMicrotask(() => {
-            this.kickScheduled = false;
-            if (this.running) return;
-            if (isBulkCommitActive()) return;
-            try {
-              this.flush();
-            } catch (err) {
-              setTimeout(() => {
-                throw err;
-              });
-            }
+        if (this.running) return;
+        if (isBulkCommitActive()) return;
+        try {
+          this.flush();
+        } catch (err) {
+          setTimeout(() => {
+            throw err;
           });
         }
-      }
-      flush() {
-        invariant(
-          !this.running,
-          "[Scheduler] flush() called while already running"
+      });
+    }
+  }
+  flush() {
+    invariant(
+      !this.running,
+      "[Scheduler] flush() called while already running"
+    );
+    if (process.env.NODE_ENV !== "production") {
+      if (isBulkCommitActive() && !this.allowSyncProgress) {
+        throw new Error(
+          "[Scheduler] flush() started during bulk commit (not allowed)"
         );
-        if (process.env.NODE_ENV !== "production") {
-          if (isBulkCommitActive() && !this.allowSyncProgress) {
-            throw new Error(
-              "[Scheduler] flush() started during bulk commit (not allowed)"
-            );
-          }
-        }
-        this.running = true;
-        this.depth = 0;
-        let fatal = null;
-        try {
-          while (this.head < this.q.length) {
-            this.depth++;
-            if (process.env.NODE_ENV !== "production" && this.depth > MAX_FLUSH_DEPTH) {
-              throw new Error(
-                `[Scheduler] exceeded MAX_FLUSH_DEPTH (${MAX_FLUSH_DEPTH}). Likely infinite update loop.`
-              );
-            }
-            const task2 = this.q[this.head++];
-            try {
-              this.executionDepth++;
-              task2();
-              this.executionDepth--;
-            } catch (err) {
-              if (this.executionDepth > 0) this.executionDepth = 0;
-              fatal = err;
-              break;
-            }
-            if (this.taskCount > 0) this.taskCount--;
-          }
-        } finally {
-          this.running = false;
-          this.depth = 0;
-          this.executionDepth = 0;
-          if (this.head >= this.q.length) {
-            this.q.length = 0;
-            this.head = 0;
-          } else if (this.head > 0) {
-            const remaining = this.q.length - this.head;
-            if (this.head > 1024 || this.head > remaining) {
-              this.q = this.q.slice(this.head);
-            } else {
-              for (let i = 0; i < remaining; i++) {
-                this.q[i] = this.q[this.head + i];
-              }
-              this.q.length = remaining;
-            }
-            this.head = 0;
-          }
-          this.flushVersion++;
-          this.resolveWaiters();
-        }
-        if (fatal) throw fatal;
       }
-      runWithSyncProgress(fn) {
-        const prev = this.allowSyncProgress;
-        this.allowSyncProgress = true;
-        const g = globalThis;
-        const origQueueMicrotask = g.queueMicrotask;
-        const origSetTimeout = g.setTimeout;
-        if (process.env.NODE_ENV !== "production") {
-          g.queueMicrotask = () => {
-            throw new Error(
-              "[Scheduler] queueMicrotask not allowed during runWithSyncProgress"
-            );
-          };
-          g.setTimeout = () => {
-            throw new Error(
-              "[Scheduler] setTimeout not allowed during runWithSyncProgress"
-            );
-          };
+    }
+    this.running = true;
+    this.depth = 0;
+    let fatal = null;
+    try {
+      while (this.head < this.q.length) {
+        this.depth++;
+        if (process.env.NODE_ENV !== "production" && this.depth > MAX_FLUSH_DEPTH) {
+          throw new Error(
+            `[Scheduler] exceeded MAX_FLUSH_DEPTH (${MAX_FLUSH_DEPTH}). Likely infinite update loop.`
+          );
         }
-        const startVersion = this.flushVersion;
+        const task = this.q[this.head++];
         try {
-          const res = fn();
-          if (!this.running && this.q.length - this.head > 0) {
-            this.flush();
-          }
-          if (process.env.NODE_ENV !== "production") {
-            if (this.q.length - this.head > 0) {
-              throw new Error(
-                "[Scheduler] tasks remain after runWithSyncProgress flush"
-              );
-            }
-          }
-          return res;
-        } finally {
-          if (process.env.NODE_ENV !== "production") {
-            g.queueMicrotask = origQueueMicrotask;
-            g.setTimeout = origSetTimeout;
-          }
-          try {
-            if (this.flushVersion === startVersion) {
-              this.flushVersion++;
-              this.resolveWaiters();
-            }
-          } catch (e) {
-            void e;
-          }
-          this.allowSyncProgress = prev;
+          this.executionDepth++;
+          task();
+          this.executionDepth--;
+        } catch (err) {
+          if (this.executionDepth > 0) this.executionDepth = 0;
+          fatal = err;
+          break;
         }
+        if (this.taskCount > 0) this.taskCount--;
       }
-      waitForFlush(targetVersion, timeoutMs = 2e3) {
-        const target = typeof targetVersion === "number" ? targetVersion : this.flushVersion + 1;
-        if (this.flushVersion >= target) return Promise.resolve();
-        return new Promise((resolve, reject) => {
-          const timer = setTimeout(() => {
-            const ns = globalThis.__ASKR__ || {};
-            const diag = {
-              flushVersion: this.flushVersion,
-              queueLen: this.q.length - this.head,
-              running: this.running,
-              inHandler: this.inHandler,
-              bulk: isBulkCommitActive(),
-              namespace: ns
-            };
-            reject(
-              new Error(
-                `waitForFlush timeout ${timeoutMs}ms: ${JSON.stringify(diag)}`
-              )
-            );
-          }, timeoutMs);
-          this.waiters.push({ target, resolve, reject, timer });
-        });
-      }
-      getState() {
-        return {
-          queueLength: this.q.length - this.head,
-          running: this.running,
-          depth: this.depth,
-          executionDepth: this.executionDepth,
-          taskCount: this.taskCount,
-          flushVersion: this.flushVersion,
-          // New fields for optional inspection
-          inHandler: this.inHandler,
-          allowSyncProgress: this.allowSyncProgress
-        };
+    } finally {
+      this.running = false;
+      this.depth = 0;
+      this.executionDepth = 0;
+      if (this.head >= this.q.length) {
+        this.q.length = 0;
+        this.head = 0;
+      } else if (this.head > 0) {
+        const remaining = this.q.length - this.head;
+        for (let i = 0; i < remaining; i++) {
+          this.q[i] = this.q[this.head + i];
+        }
+        this.q.length = remaining;
+        this.head = 0;
       }
-      setInHandler(v) {
-        this.inHandler = v;
+      this.flushVersion++;
+      this.resolveWaiters();
+    }
+    if (fatal) throw fatal;
+  }
+  runWithSyncProgress(fn) {
+    const prev = this.allowSyncProgress;
+    this.allowSyncProgress = true;
+    const g = globalThis;
+    const origQueueMicrotask = g.queueMicrotask;
+    const origSetTimeout = g.setTimeout;
+    if (process.env.NODE_ENV !== "production") {
+      g.queueMicrotask = () => {
+        throw new Error(
+          "[Scheduler] queueMicrotask not allowed during runWithSyncProgress"
+        );
+      };
+      g.setTimeout = () => {
+        throw new Error(
+          "[Scheduler] setTimeout not allowed during runWithSyncProgress"
+        );
+      };
+    }
+    const startVersion = this.flushVersion;
+    try {
+      const res = fn();
+      if (!this.running && this.q.length - this.head > 0) {
+        this.flush();
       }
-      isInHandler() {
-        return this.inHandler;
+      if (process.env.NODE_ENV !== "production") {
+        if (this.q.length - this.head > 0) {
+          throw new Error(
+            "[Scheduler] tasks remain after runWithSyncProgress flush"
+          );
+        }
       }
-      isExecuting() {
-        return this.running || this.executionDepth > 0;
+      return res;
+    } finally {
+      if (process.env.NODE_ENV !== "production") {
+        g.queueMicrotask = origQueueMicrotask;
+        g.setTimeout = origSetTimeout;
       }
-      // Clear pending synchronous tasks (used by fastlane enter/exit)
-      clearPendingSyncTasks() {
-        const remaining = this.q.length - this.head;
-        if (remaining <= 0) return 0;
-        if (this.running) {
-          this.q.length = this.head;
-          this.taskCount = Math.max(0, this.taskCount - remaining);
-          queueMicrotask(() => {
-            try {
-              this.flushVersion++;
-              this.resolveWaiters();
-            } catch (e) {
-              void e;
-            }
-          });
-          return remaining;
+      try {
+        if (this.flushVersion === startVersion) {
+          this.flushVersion++;
+          this.resolveWaiters();
         }
-        this.q.length = 0;
-        this.head = 0;
-        this.taskCount = Math.max(0, this.taskCount - remaining);
-        this.flushVersion++;
-        this.resolveWaiters();
-        return remaining;
+      } catch (e) {
       }
-      resolveWaiters() {
-        if (this.waiters.length === 0) return;
-        const ready = [];
-        const remaining = [];
-        for (const w of this.waiters) {
-          if (this.flushVersion >= w.target) {
-            if (w.timer) clearTimeout(w.timer);
-            ready.push(w.resolve);
-          } else {
-            remaining.push(w);
-          }
+      this.allowSyncProgress = prev;
+    }
+  }
+  waitForFlush(targetVersion, timeoutMs = 2e3) {
+    const target = typeof targetVersion === "number" ? targetVersion : this.flushVersion + 1;
+    if (this.flushVersion >= target) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const ns = globalThis.__ASKR__ || {};
+        const diag = {
+          flushVersion: this.flushVersion,
+          queueLen: this.q.length - this.head,
+          running: this.running,
+          inHandler: this.inHandler,
+          bulk: isBulkCommitActive(),
+          namespace: ns
+        };
+        reject(
+          new Error(
+            `waitForFlush timeout ${timeoutMs}ms: ${JSON.stringify(diag)}`
+          )
+        );
+      }, timeoutMs);
+      this.waiters.push({ target, resolve, reject, timer });
+    });
+  }
+  getState() {
+    return {
+      queueLength: this.q.length - this.head,
+      running: this.running,
+      depth: this.depth,
+      executionDepth: this.executionDepth,
+      taskCount: this.taskCount,
+      flushVersion: this.flushVersion,
+      // New fields for optional inspection
+      inHandler: this.inHandler,
+      allowSyncProgress: this.allowSyncProgress
+    };
+  }
+  setInHandler(v) {
+    this.inHandler = v;
+  }
+  isInHandler() {
+    return this.inHandler;
+  }
+  isExecuting() {
+    return this.running || this.executionDepth > 0;
+  }
+  // Clear pending synchronous tasks (used by fastlane enter/exit)
+  clearPendingSyncTasks() {
+    const remaining = this.q.length - this.head;
+    if (remaining <= 0) return 0;
+    if (this.running) {
+      this.q.length = this.head;
+      this.taskCount = Math.max(0, this.taskCount - remaining);
+      queueMicrotask(() => {
+        try {
+          this.flushVersion++;
+          this.resolveWaiters();
+        } catch (e) {
         }
-        this.waiters = remaining;
-        for (const r of ready) r();
+      });
+      return remaining;
+    }
+    this.q.length = 0;
+    this.head = 0;
+    this.taskCount = Math.max(0, this.taskCount - remaining);
+    this.flushVersion++;
+    this.resolveWaiters();
+    return remaining;
+  }
+  resolveWaiters() {
+    if (this.waiters.length === 0) return;
+    const ready = [];
+    const remaining = [];
+    for (const w of this.waiters) {
+      if (this.flushVersion >= w.target) {
+        if (w.timer) clearTimeout(w.timer);
+        ready.push(w.resolve);
+      } else {
+        remaining.push(w);
       }
-    };
-    globalScheduler = new Scheduler();
+    }
+    this.waiters = remaining;
+    for (const r of ready) r();
   }
-});
+};
+var globalScheduler = new Scheduler();
+function isSchedulerExecuting() {
+  return globalScheduler.isExecuting();
+}
 
 // src/runtime/context.ts
+var CONTEXT_FRAME_SYMBOL = /* @__PURE__ */ Symbol("__tempoContextFrame__");
+var currentContextFrame = null;
 function withContext(frame, fn) {
   const oldFrame = currentContextFrame;
   currentContextFrame = frame;
@@ -373,125 +359,9 @@ 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 init_context = __esm({
-  "src/runtime/context.ts"() {
-    "use strict";
-    init_component();
-    CONTEXT_FRAME_SYMBOL = /* @__PURE__ */ Symbol("__tempoContextFrame__");
-    currentContextFrame = null;
-    currentAsyncResourceFrame = null;
-  }
-});
 
 // src/renderer/diag/index.ts
 function getDiagMap() {
@@ -500,7 +370,6 @@ function getDiagMap() {
     if (!root.__ASKR_DIAG) root.__ASKR_DIAG = {};
     return root.__ASKR_DIAG;
   } catch (e) {
-    void e;
     return {};
   }
 }
@@ -524,7 +393,6 @@ function __ASKR_set(key, value) {
       void e;
     }
   } catch (e) {
-    void e;
   }
 }
 function __ASKR_incCounter(key) {
@@ -546,180 +414,8 @@ function __ASKR_incCounter(key) {
       void e;
     }
   } catch (e) {
-    void e;
   }
 }
-var init_diag = __esm({
-  "src/renderer/diag/index.ts"() {
-    "use strict";
-  }
-});
-
-// src/runtime/dev-namespace.ts
-function getDevNamespace() {
-  if (process.env.NODE_ENV === "production") return {};
-  try {
-    const g = globalThis;
-    if (!g.__ASKR__) g.__ASKR__ = {};
-    return g.__ASKR__;
-  } catch {
-    return {};
-  }
-}
-function setDevValue(key, value) {
-  if (process.env.NODE_ENV === "production") return;
-  try {
-    getDevNamespace()[key] = value;
-  } catch {
-  }
-}
-function getDevValue(key) {
-  if (process.env.NODE_ENV === "production") return void 0;
-  try {
-    return getDevNamespace()[key];
-  } catch {
-    return void 0;
-  }
-}
-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) {
@@ -742,8 +438,8 @@ function createWrappedHandler(handler, flushAfter = false) {
     } finally {
       globalScheduler.setInHandler(false);
       if (flushAfter) {
-        const state2 = globalScheduler.getState();
-        if ((state2.queueLength ?? 0) > 0 && !state2.running) {
+        const state = globalScheduler.getState();
+        if ((state.queueLength ?? 0) > 0 && !state.running) {
           queueMicrotask(() => {
             try {
               if (!globalScheduler.isExecuting()) globalScheduler.flush();
@@ -809,8 +505,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);
@@ -851,16 +546,9 @@ function logFastPathDebug(message, indexOrData, data) {
 function now() {
   return typeof performance !== "undefined" && performance.now ? performance.now() : Date.now();
 }
-var init_utils = __esm({
-  "src/renderer/utils.ts"() {
-    "use strict";
-    init_scheduler();
-    init_logger();
-    init_diag();
-  }
-});
 
 // src/renderer/keyed.ts
+var keyedElements = /* @__PURE__ */ new WeakMap();
 function getKeyMapForElement(el) {
   return keyedElements.get(el);
 }
@@ -884,6 +572,7 @@ function populateKeyMapForElement(parent) {
   } catch {
   }
 }
+var _reconcilerRecordedParents = /* @__PURE__ */ new WeakSet();
 function extractKeyedVnodes(newChildren) {
   const result = [];
   for (const child of newChildren) {
@@ -975,398 +664,739 @@ function isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap) {
     hasPropChanges
   };
 }
-var keyedElements, _reconcilerRecordedParents;
-var init_keyed = __esm({
-  "src/renderer/keyed.ts"() {
-    "use strict";
-    init_utils();
-    keyedElements = /* @__PURE__ */ new WeakMap();
-    _reconcilerRecordedParents = /* @__PURE__ */ new WeakSet();
-  }
-});
 
-// src/jsx/types.ts
-var ELEMENT_TYPE, Fragment;
-var init_types2 = __esm({
-  "src/jsx/types.ts"() {
-    "use strict";
-    ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("askr.element");
-    Fragment = /* @__PURE__ */ Symbol.for("askr.fragment");
-  }
-});
+// src/common/jsx.ts
+var ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("askr.element");
+var 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
-  };
-}
-function jsx(type, props, key) {
-  return jsxDEV(type, props, key);
+// 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 jsxs(type, props, key) {
-  return jsxDEV(type, props, key);
+function setDevValue(key, value) {
+  if (process.env.NODE_ENV === "production") return;
+  try {
+    getDevNamespace()[key] = value;
+  } catch {
+  }
 }
-var ELEMENT_TYPE2, Fragment2;
-var init_jsx_runtime = __esm({
-  "src/jsx/jsx-runtime.ts"() {
-    "use strict";
-    init_types2();
-    ELEMENT_TYPE2 = /* @__PURE__ */ Symbol.for("askr.element");
-    Fragment2 = /* @__PURE__ */ Symbol.for("askr.fragment");
+function getDevValue(key) {
+  if (process.env.NODE_ENV === "production") return void 0;
+  try {
+    return getDevNamespace()[key];
+  } catch {
+    return void 0;
   }
-});
+}
 
-// 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
+var _bulkCommitActive = false;
+var _appliedParents = null;
+function enterBulkCommit() {
+  _bulkCommitActive = true;
+  _appliedParents = /* @__PURE__ */ new WeakSet();
+  try {
+    const cleared = globalScheduler.clearPendingSyncTasks?.() ?? 0;
+    setDevValue("__ASKR_FASTLANE_CLEARED_TASKS", cleared);
+  } catch (err) {
+    if (process.env.NODE_ENV !== "production") throw err;
   }
-  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) {
   }
-  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 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 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 (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 (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 createDOMNode(node) {
-  if (!IS_DOM_AVAILABLE) {
-    if (process.env.NODE_ENV !== "production") {
+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 {
-        logger.warn("[Askr] createDOMNode called in non-DOM environment");
-      } catch {
+        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 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;
+    return true;
+  } finally {
+    exitBulkCommit();
   }
-  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);
+  if (process.env.NODE_ENV !== "production") {
+    if (isBulkCommitActive2()) {
+      throw new Error(
+        "Fast-lane invariant violated: bulk commit flag still set 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 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"
+    );
   }
-  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) {
+  if (invariants.mountOps > 0) {
     throw new Error(
-      "Async components are not supported. Use resource() for async work."
+      "Fast-lane invariant violated: mount operations were registered during bulk commit"
     );
   }
-  let childInstance = node.__instance;
-  if (!childInstance) {
-    childInstance = createComponentInstance(
-      `comp-${Math.random().toString(36).slice(2, 7)}`,
-      componentFn,
-      props || {},
-      null
+  if (invariants.cleanupFns > 0) {
+    throw new Error(
+      "Fast-lane invariant violated: cleanup functions were added during bulk commit"
     );
-    node.__instance = childInstance;
   }
-  if (snapshot) {
-    childInstance.ownerFrame = snapshot;
+  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"
+    );
   }
-  const result = withContext(
-    snapshot,
-    () => renderComponentInline(childInstance)
+  let finalState = globalScheduler.getState();
+  const executing = globalScheduler.isExecuting();
+  let outstandingAfter = Math.max(
+    0,
+    finalState.taskCount - (executing ? 1 : 0)
   );
-  if (result instanceof Promise) {
-    throw new Error(
-      "Async components are not supported. Components must return synchronously."
+  if (outstandingAfter !== 0) {
+    let attempts = 0;
+    while (attempts < 5) {
+      const cleared = globalScheduler.clearPendingSyncTasks?.() ?? 0;
+      if (cleared === 0) break;
+      attempts++;
+    }
+    finalState = globalScheduler.getState();
+    outstandingAfter = Math.max(
+      0,
+      finalState.taskCount - (globalScheduler.isExecuting() ? 1 : 0)
     );
+    if (outstandingAfter !== 0) {
+      console.error(
+        "[FASTLANE] Post-commit enqueue logs:",
+        getDevValue("__ENQUEUE_LOGS")
+      );
+      console.error(
+        "[FASTLANE] Cleared counts:",
+        getDevValue("__FASTLANE_CLEARED_TASKS"),
+        getDevValue("__FASTLANE_CLEARED_AFTER")
+      );
+      throw new Error(
+        `Fast-lane invariant violated: scheduler has ${finalState.taskCount} pending task(s) after commit`
+      );
+    }
   }
-  const dom = withContext(snapshot, () => createDOMNode(result));
-  if (dom instanceof Element) {
-    mountInstanceInline(childInstance, dom);
-    return 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;
   }
-  if (!dom) {
-    const placeholder = document.createComment("");
-    childInstance._placeholder = placeholder;
-    childInstance.mounted = true;
-    childInstance.notifyUpdate = childInstance._enqueueRun;
-    return placeholder;
+  try {
+    return commitReorderOnly(instance, result);
+  } catch (err) {
+    if (process.env.NODE_ENV !== "production") throw err;
+    return false;
   }
-  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);
+if (typeof globalThis !== "undefined") {
+  globalThis.__ASKR_FASTLANE = {
+    isBulkCommitActive: isBulkCommitActive2,
+    enterBulkCommit,
+    exitBulkCommit,
+    tryRuntimeFastLaneSync,
+    markFastPathApplied,
+    isFastPathApplied
+  };
+}
+
+// src/common/vnode.ts
+function _isDOMElement(node) {
+  return typeof node === "object" && node !== null && "type" in node;
+}
+
+// src/renderer/cleanup.ts
+function cleanupSingleInstance(node, errors, strict) {
+  const inst = node.__ASKR_INSTANCE;
+  if (!inst) return;
+  try {
+    cleanupComponent(inst);
+  } catch (err) {
+    logger.warn("[Askr] cleanupComponent failed:", err);
+  }
+  try {
+    delete node.__ASKR_INSTANCE;
+  } catch (e) {
+  }
+}
+function forEachDescendantElement(root, visit) {
+  try {
+    const doc = root.ownerDocument;
+    const createTreeWalker = doc?.createTreeWalker;
+    if (typeof createTreeWalker === "function") {
+      const walker = createTreeWalker.call(doc, root, 1);
+      let n = walker.firstChild();
+      while (n) {
+        visit(n);
+        n = walker.nextNode();
       }
-    } else {
-      const dom = createDOMNode(children);
-      if (dom) fragment.appendChild(dom);
+      return;
     }
+  } catch {
+  }
+  const descendants = root.querySelectorAll("*");
+  for (let i = 0; i < descendants.length; i++) {
+    visit(descendants[i]);
   }
-  return fragment;
 }
-function updateElementFromVnode(el, vnode, updateChildren = true) {
-  if (!_isDOMElement(vnode)) {
-    return;
+function cleanupInstanceIfPresent(node, opts) {
+  if (!node || !(node instanceof Element)) return;
+  const strict = false;
+  const errors = null;
+  try {
+    cleanupSingleInstance(node, errors, strict);
+  } catch (err) {
+    logger.warn("[Askr] cleanupInstanceIfPresent failed:", err);
   }
-  const props = vnode.props || {};
-  materializeKey(el, vnode, props);
-  const existingListeners = elementListeners.get(el);
-  const desiredEventNames = /* @__PURE__ */ new Set();
+  try {
+    forEachDescendantElement(node, (d) => {
+      try {
+        cleanupSingleInstance(d, errors, strict);
+      } catch (err) {
+        if (strict) ;
+        else
+          logger.warn(
+            "[Askr] cleanupInstanceIfPresent descendant cleanup failed:",
+            err
+          );
+      }
+    });
+  } catch (err) {
+    logger.warn(
+        "[Askr] cleanupInstanceIfPresent descendant query failed:",
+        err
+      );
+  }
+}
+function cleanupInstancesUnder(node, opts) {
+  cleanupInstanceIfPresent(node);
+}
+var elementListeners = /* @__PURE__ */ new WeakMap();
+function removeElementListeners(element) {
+  const map = elementListeners.get(element);
+  if (map) {
+    for (const [eventName, entry] of map) {
+      if (entry.options !== void 0)
+        element.removeEventListener(eventName, entry.handler, entry.options);
+      else element.removeEventListener(eventName, entry.handler);
+    }
+    elementListeners.delete(element);
+  }
+}
+function removeAllListeners(root) {
+  if (!root) return;
+  removeElementListeners(root);
+  forEachDescendantElement(root, removeElementListeners);
+}
+
+// src/renderer/dom.ts
+var IS_DOM_AVAILABLE = typeof document !== "undefined";
+function addTrackedListener(el, eventName, handler) {
+  const wrappedHandler = createWrappedHandler(handler, true);
+  const options = getPassiveOptions(eventName);
+  if (options !== void 0) {
+    el.addEventListener(eventName, wrappedHandler, options);
+  } else {
+    el.addEventListener(eventName, wrappedHandler);
+  }
+  if (!elementListeners.has(el)) {
+    elementListeners.set(el, /* @__PURE__ */ new Map());
+  }
+  elementListeners.get(el).set(eventName, {
+    handler: wrappedHandler,
+    original: handler,
+    options
+  });
+}
+function applyPropsToElement(el, props, tagName) {
   for (const key in props) {
     const value = props[key];
     if (isSkippedProp(key)) continue;
+    if (value === void 0 || value === null || value === false) continue;
     const eventName = parseEventName(key);
-    if (value === void 0 || value === null || value === false) {
-      if (key === "class" || key === "className") {
-        el.className = "";
-      } else if (eventName && existingListeners?.has(eventName)) {
-        const entry = existingListeners.get(eventName);
-        if (entry.options !== void 0) {
-          el.removeEventListener(eventName, entry.handler, entry.options);
-        } else {
-          el.removeEventListener(eventName, entry.handler);
-        }
-        existingListeners.delete(eventName);
-      } else {
-        el.removeAttribute(key);
-      }
+    if (eventName) {
+      addTrackedListener(el, eventName, value);
       continue;
     }
     if (key === "class" || key === "className") {
       el.className = String(value);
     } else if (key === "value" || key === "checked") {
-      el[key] = value;
-    } else if (eventName) {
-      desiredEventNames.add(eventName);
-      const existing = existingListeners?.get(eventName);
-      if (existing && existing.original === value) {
-        continue;
-      }
-      if (existing) {
-        el.removeEventListener(eventName, existing.handler);
-      }
-      const wrappedHandler = createWrappedHandler(
-        value,
-        false
-      );
-      const options = getPassiveOptions(eventName);
-      if (options !== void 0) {
-        el.addEventListener(eventName, wrappedHandler, options);
-      } else {
-        el.addEventListener(eventName, wrappedHandler);
-      }
-      if (!elementListeners.has(el)) {
-        elementListeners.set(el, /* @__PURE__ */ new Map());
-      }
-      elementListeners.get(el).set(eventName, {
-        handler: wrappedHandler,
-        original: value,
-        options
-      });
+      applyFormControlProp(el, key, value, tagName);
     } else {
       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);
-      }
+}
+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)));
     }
-    if (existingListeners.size === 0) elementListeners.delete(el);
-  }
-  if (updateChildren) {
-    const children = vnode.children || props.children;
-    updateElementChildren(el, children);
   }
 }
-function updateElementChildren(el, children) {
-  if (!children) {
-    el.textContent = "";
-    return;
+function materializeKey(el, vnode, props) {
+  const vnodeKey = vnode.key ?? props?.key;
+  if (vnodeKey !== void 0) {
+    el.setAttribute("data-key", String(vnodeKey));
   }
-  if (!Array.isArray(children) && (typeof children === "string" || typeof children === "number")) {
-    if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
-      el.firstChild.data = String(children);
-    } else {
-      el.textContent = String(children);
+}
+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;
+      }
     }
-    return;
   }
-  if (Array.isArray(children)) {
-    updateUnkeyedChildren(el, children);
-    return;
+  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.'
+      );
+    }
   }
-  el.textContent = "";
-  const dom = createDOMNode(children);
-  if (dom) el.appendChild(dom);
 }
-function updateUnkeyedChildren(parent, newChildren) {
-  const existing = Array.from(parent.children);
-  if (newChildren.length === 1 && existing.length === 0 && parent.childNodes.length === 1) {
-    const firstNewChild = newChildren[0];
-    const firstExisting = parent.firstChild;
-    if ((typeof firstNewChild === "string" || typeof firstNewChild === "number") && firstExisting?.nodeType === 3) {
-      firstExisting.data = String(firstNewChild);
-      return;
+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 (existing.length === 0 && parent.childNodes.length > 0) {
-    parent.textContent = "";
+  if (typeof node === "string") {
+    return document.createTextNode(node);
   }
-  const max = Math.max(existing.length, newChildren.length);
-  for (let i = 0; i < max; i++) {
-    const current2 = existing[i];
-    const next = newChildren[i];
-    if (next === void 0 && current2) {
-      cleanupInstanceIfPresent(current2);
-      current2.remove();
-      continue;
-    }
-    if (!current2 && next !== void 0) {
-      const dom = createDOMNode(next);
-      if (dom) parent.appendChild(dom);
-      continue;
-    }
-    if (!current2 || next === void 0) continue;
-    if (typeof next === "string" || typeof next === "number") {
-      current2.textContent = String(next);
-    } else if (_isDOMElement(next)) {
+  if (typeof node === "number") {
+    return document.createTextNode(String(node));
+  }
+  if (!node) {
+    return null;
+  }
+  if (Array.isArray(node)) {
+    const fragment = document.createDocumentFragment();
+    for (const child of node) {
+      const dom = createDOMNode(child);
+      if (dom) fragment.appendChild(dom);
+    }
+    return fragment;
+  }
+  if (typeof node === "object" && node !== null && "type" in node) {
+    const type = node.type;
+    const props = node.props || {};
+    if (typeof type === "string") {
+      return createIntrinsicElement(node, type, props);
+    }
+    if (typeof type === "function") {
+      return createComponentElement(node, type, props);
+    }
+    if (typeof type === "symbol" && (type === Fragment || String(type) === "Symbol(Fragment)")) {
+      return createFragmentElement(node, props);
+    }
+  }
+  return null;
+}
+function createIntrinsicElement(node, type, props) {
+  const el = document.createElement(type);
+  materializeKey(el, node, props);
+  applyPropsToElement(el, props, type);
+  const children = props.children || node.children;
+  if (children) {
+    if (Array.isArray(children)) {
+      warnMissingKeys(children);
+      for (const child of children) {
+        const dom = createDOMNode(child);
+        if (dom) el.appendChild(dom);
+      }
+    } else {
+      const dom = createDOMNode(children);
+      if (dom) el.appendChild(dom);
+    }
+  }
+  return el;
+}
+function createComponentElement(node, type, props) {
+  const frame = node[CONTEXT_FRAME_SYMBOL];
+  const snapshot = frame || getCurrentContextFrame();
+  const componentFn = type;
+  const isAsync = componentFn.constructor.name === "AsyncFunction";
+  if (isAsync) {
+    throw new Error(
+      "Async components are not supported. Use resource() for async work."
+    );
+  }
+  let childInstance = node.__instance;
+  if (!childInstance) {
+    childInstance = createComponentInstance(
+      `comp-${Math.random().toString(36).slice(2, 7)}`,
+      componentFn,
+      props || {},
+      null
+    );
+    node.__instance = childInstance;
+  }
+  if (snapshot) {
+    childInstance.ownerFrame = snapshot;
+  }
+  const result = withContext(
+    snapshot,
+    () => renderComponentInline(childInstance)
+  );
+  if (result instanceof Promise) {
+    throw new Error(
+      "Async components are not supported. Components must return synchronously."
+    );
+  }
+  const dom = withContext(snapshot, () => createDOMNode(result));
+  if (dom instanceof Element) {
+    mountInstanceInline(childInstance, dom);
+    return dom;
+  }
+  if (!dom) {
+    const placeholder = document.createComment("");
+    childInstance._placeholder = placeholder;
+    childInstance.mounted = true;
+    childInstance.notifyUpdate = childInstance._enqueueRun;
+    return placeholder;
+  }
+  const host = document.createElement("div");
+  host.appendChild(dom);
+  mountInstanceInline(childInstance, host);
+  return host;
+}
+function createFragmentElement(node, props) {
+  const fragment = document.createDocumentFragment();
+  const children = props.children || node.children;
+  if (children) {
+    if (Array.isArray(children)) {
+      for (const child of children) {
+        const dom = createDOMNode(child);
+        if (dom) fragment.appendChild(dom);
+      }
+    } else {
+      const dom = createDOMNode(children);
+      if (dom) fragment.appendChild(dom);
+    }
+  }
+  return fragment;
+}
+function updateElementFromVnode(el, vnode, updateChildren = true) {
+  if (!_isDOMElement(vnode)) {
+    return;
+  }
+  const props = vnode.props || {};
+  materializeKey(el, vnode, props);
+  const existingListeners = elementListeners.get(el);
+  let desiredEventNames = null;
+  for (const key in props) {
+    const value = props[key];
+    if (isSkippedProp(key)) continue;
+    const eventName = parseEventName(key);
+    if (value === void 0 || value === null || value === false) {
+      if (key === "class" || key === "className") {
+        el.className = "";
+      } else if (eventName && existingListeners?.has(eventName)) {
+        const entry = existingListeners.get(eventName);
+        if (entry.options !== void 0) {
+          el.removeEventListener(eventName, entry.handler, entry.options);
+        } else {
+          el.removeEventListener(eventName, entry.handler);
+        }
+        existingListeners.delete(eventName);
+      } else {
+        el.removeAttribute(key);
+      }
+      continue;
+    }
+    if (key === "class" || key === "className") {
+      el.className = String(value);
+    } else if (key === "value" || key === "checked") {
+      el[key] = value;
+    } else if (eventName) {
+      if (existingListeners && existingListeners.size > 0) {
+        (desiredEventNames ??= /* @__PURE__ */ new Set()).add(eventName);
+      }
+      const existing = existingListeners?.get(eventName);
+      if (existing && existing.original === value) {
+        continue;
+      }
+      if (existing) {
+        if (existing.options !== void 0) {
+          el.removeEventListener(eventName, existing.handler, existing.options);
+        } else {
+          el.removeEventListener(eventName, existing.handler);
+        }
+      }
+      const wrappedHandler = createWrappedHandler(
+        value,
+        false
+      );
+      const options = getPassiveOptions(eventName);
+      if (options !== void 0) {
+        el.addEventListener(eventName, wrappedHandler, options);
+      } else {
+        el.addEventListener(eventName, wrappedHandler);
+      }
+      if (!elementListeners.has(el)) {
+        elementListeners.set(el, /* @__PURE__ */ new Map());
+      }
+      elementListeners.get(el).set(eventName, {
+        handler: wrappedHandler,
+        original: value,
+        options
+      });
+    } else {
+      el.setAttribute(key, String(value));
+    }
+  }
+  if (existingListeners && existingListeners.size > 0) {
+    if (desiredEventNames === null) {
+      for (const [eventName, entry] of existingListeners) {
+        if (entry.options !== void 0) {
+          el.removeEventListener(eventName, entry.handler, entry.options);
+        } else {
+          el.removeEventListener(eventName, entry.handler);
+        }
+      }
+      elementListeners.delete(el);
+    } else {
+      for (const [eventName, entry] of existingListeners) {
+        if (!desiredEventNames.has(eventName)) {
+          if (entry.options !== void 0) {
+            el.removeEventListener(eventName, entry.handler, entry.options);
+          } else {
+            el.removeEventListener(eventName, entry.handler);
+          }
+          existingListeners.delete(eventName);
+        }
+      }
+      if (existingListeners.size === 0) elementListeners.delete(el);
+    }
+  }
+  if (updateChildren) {
+    const children = vnode.children || props.children;
+    updateElementChildren(el, children);
+  }
+}
+function updateElementChildren(el, children) {
+  if (!children) {
+    el.textContent = "";
+    return;
+  }
+  if (!Array.isArray(children) && (typeof children === "string" || typeof children === "number")) {
+    if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
+      el.firstChild.data = String(children);
+    } else {
+      el.textContent = String(children);
+    }
+    return;
+  }
+  if (Array.isArray(children)) {
+    updateUnkeyedChildren(el, children);
+    return;
+  }
+  el.textContent = "";
+  const dom = createDOMNode(children);
+  if (dom) el.appendChild(dom);
+}
+function updateUnkeyedChildren(parent, newChildren) {
+  const existing = Array.from(parent.children);
+  if (newChildren.length === 1 && existing.length === 0 && parent.childNodes.length === 1) {
+    const firstNewChild = newChildren[0];
+    const firstExisting = parent.firstChild;
+    if ((typeof firstNewChild === "string" || typeof firstNewChild === "number") && firstExisting?.nodeType === 3) {
+      firstExisting.data = String(firstNewChild);
+      return;
+    }
+  }
+  if (existing.length === 0 && parent.childNodes.length > 0) {
+    parent.textContent = "";
+  }
+  const max = Math.max(existing.length, newChildren.length);
+  for (let i = 0; i < max; i++) {
+    const current2 = existing[i];
+    const next = newChildren[i];
+    if (next === void 0 && current2) {
+      cleanupInstanceIfPresent(current2);
+      current2.remove();
+      continue;
+    }
+    if (!current2 && next !== void 0) {
+      const dom = createDOMNode(next);
+      if (dom) parent.appendChild(dom);
+      continue;
+    }
+    if (!current2 || next === void 0) continue;
+    if (typeof next === "string" || typeof next === "number") {
+      current2.textContent = String(next);
+    } else if (_isDOMElement(next)) {
       if (typeof next.type === "string") {
-        if (current2.tagName.toLowerCase() === next.type.toLowerCase()) {
+        if (tagsEqualIgnoreCase(current2.tagName, next.type)) {
           updateElementFromVnode(current2, next);
         } else {
           const dom = createDOMNode(next);
@@ -1399,31 +1429,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,29 +1470,106 @@ 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 setTextNodeData(el, text) {
-  if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
-    el.firstChild.data = text;
+function tryUpdateTwoChildTextPattern(parentEl, vnode) {
+  const vnodeChildren = vnode.children || vnode.props?.children;
+  if (!Array.isArray(vnodeChildren) || vnodeChildren.length !== 2) return false;
+  const c0 = vnodeChildren[0];
+  const c1 = vnodeChildren[1];
+  if (!_isDOMElement(c0) || !_isDOMElement(c1)) return false;
+  if (typeof c0.type !== "string" || typeof c1.type !== "string") return false;
+  const el0 = parentEl.children[0];
+  const el1 = parentEl.children[1];
+  if (!el0 || !el1) return false;
+  if (!tagsEqualIgnoreCase(el0.tagName, c0.type)) return false;
+  if (!tagsEqualIgnoreCase(el1.tagName, c1.type)) return false;
+  const t0 = c0.children || c0.props?.children;
+  const t1 = c1.children || c1.props?.children;
+  if (typeof t0 === "string" || typeof t0 === "number") {
+    setTextNodeData(el0, String(t0));
+  } else if (Array.isArray(t0) && t0.length === 1 && (typeof t0[0] === "string" || typeof t0[0] === "number")) {
+    setTextNodeData(el0, String(t0[0]));
+  } else {
+    return false;
+  }
+  if (typeof t1 === "string" || typeof t1 === "number") {
+    setTextNodeData(el1, String(t1));
+  } else if (Array.isArray(t1) && t1.length === 1 && (typeof t1[0] === "string" || typeof t1[0] === "number")) {
+    setTextNodeData(el1, String(t1[0]));
+  } else {
+    return false;
+  }
+  return true;
+}
+function setTextNodeData(el, text) {
+  if (el.childNodes.length === 1 && el.firstChild?.nodeType === 3) {
+    el.firstChild.data = text;
   } else {
     el.textContent = text;
   }
 }
 function setDataKey(el, key, onSet) {
   try {
-    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 +1584,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 +1607,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 +1641,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 +1654,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;
@@ -1644,22 +1755,6 @@ function recordBulkDiag(data) {
     }
   }
 }
-var IS_DOM_AVAILABLE;
-var init_dom = __esm({
-  "src/renderer/dom.ts"() {
-    "use strict";
-    init_logger();
-    init_jsx_runtime();
-    init_context();
-    init_component();
-    init_cleanup();
-    init_diag();
-    init_types();
-    init_keyed();
-    init_utils();
-    IS_DOM_AVAILABLE = typeof document !== "undefined";
-  }
-});
 
 // src/renderer/fastpath.ts
 function applyRendererFastPath(parent, keyedVnodes, oldKeyMap, unkeyedVnodes) {
@@ -1682,14 +1777,11 @@ function applyRendererFastPath(parent, keyedVnodes, oldKeyMap, unkeyedVnodes) {
         parentChildrenArr[i] = pc[i];
     } catch (e) {
       parentChildrenArr = void 0;
-      void e;
     }
   } else {
     localOldKeyMap = /* @__PURE__ */ new Map();
     try {
-      const parentChildren = Array.from(parent.children);
-      for (let i = 0; i < parentChildren.length; i++) {
-        const ch = parentChildren[i];
+      for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {
         const k = ch.getAttribute("data-key");
         if (k !== null) {
           localOldKeyMap.set(k, ch);
@@ -1699,7 +1791,6 @@ function applyRendererFastPath(parent, keyedVnodes, oldKeyMap, unkeyedVnodes) {
       }
     } catch (e) {
       localOldKeyMap = void 0;
-      void e;
     }
   }
   const finalNodes = [];
@@ -1753,11 +1844,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;
@@ -1820,26 +1911,25 @@ function applyRendererFastPath(parent, keyedVnodes, oldKeyMap, unkeyedVnodes) {
     }
     return newKeyMap;
   } catch (e) {
-    void e;
     return null;
   }
 }
-var init_fastpath = __esm({
-  "src/renderer/fastpath.ts"() {
-    "use strict";
-    init_dom();
-    init_keyed();
-    init_logger();
-    init_cleanup();
-    init_diag();
-    init_scheduler();
-    init_fastlane_shared();
-  }
-});
 
 // src/renderer/reconcile.ts
+function 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) {
-  logReconcileDebug(newChildren);
   const { keyedVnodes, unkeyedVnodes } = partitionChildren(newChildren);
   const fastPathResult = tryFastPaths(
     parent,
@@ -1851,20 +1941,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 +1998,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 +2018,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 +2026,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 +2044,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 +2105,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 +2134,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 +2181,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 +2200,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,30 +2214,33 @@ 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 {
   }
   recordDOMReplace("reconcile");
   parent.replaceChildren(fragment);
 }
-var init_reconcile = __esm({
-  "src/renderer/reconcile.ts"() {
-    "use strict";
-    init_dom();
-    init_keyed();
-    init_cleanup();
-    init_fastlane_shared();
-    init_fastpath();
-    init_logger();
-    init_utils();
-  }
-});
 
 // src/renderer/evaluate.ts
+var domRanges = /* @__PURE__ */ new WeakMap();
+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 +2263,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 +2284,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") {
@@ -2321,19 +2397,22 @@ function updateElementChildren2(element, vnodeChildren) {
 function smartUpdateElement(element, vnode) {
   const vnodeChildren = vnode.children || vnode.props?.children;
   const textCheck = checkSimpleText(vnodeChildren);
-  if (textCheck.isSimple && tryUpdateTextInPlace(element, textCheck.text)) {
-  } else {
+  if (textCheck.isSimple && tryUpdateTextInPlace(element, textCheck.text)) ; else {
     updateElementChildren2(element, vnodeChildren);
   }
   updateElementFromVnode(element, vnode, false);
 }
 function processFragmentChildren(target, childArray) {
-  const existingChildren = Array.from(target.children);
+  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 +2423,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,
@@ -2419,7 +2488,6 @@ function evaluate(node, target, context) {
       try {
         console.warn("[Askr] evaluate() called in non-DOM environment; no-op.");
       } catch (e) {
-        void e;
       }
     }
     return;
@@ -2458,7 +2526,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 = "";
@@ -2472,44 +2540,16 @@ function evaluate(node, target, context) {
     }
   }
 }
-var domRanges;
-var init_evaluate = __esm({
-  "src/renderer/evaluate.ts"() {
-    "use strict";
-    init_scheduler();
-    init_logger();
-    init_cleanup();
-    init_keyed();
-    init_reconcile();
-    init_types();
-    init_dom();
-    init_diag();
-    init_types2();
-    domRanges = /* @__PURE__ */ new WeakMap();
-  }
-});
 
 // src/renderer/index.ts
-var init_renderer = __esm({
-  "src/renderer/index.ts"() {
-    "use strict";
-    init_types();
-    init_cleanup();
-    init_keyed();
-    init_dom();
-    init_evaluate();
-    init_evaluate();
-    init_keyed();
-    if (typeof globalThis !== "undefined") {
-      const _g = globalThis;
-      _g.__ASKR_RENDERER = {
-        evaluate,
-        isKeyedReorderFastPathEligible,
-        getKeyMapForElement
-      };
-    }
-  }
-});
+if (typeof globalThis !== "undefined") {
+  const _g = globalThis;
+  _g.__ASKR_RENDERER = {
+    evaluate,
+    isKeyedReorderFastPathEligible,
+    getKeyMapForElement
+  };
+}
 
 // src/runtime/component.ts
 function createComponentInstance(id, fn, props, target) {
@@ -2561,26 +2601,13 @@ function createComponentInstance(id, fn, props, target) {
   };
   return instance;
 }
+var currentInstance = null;
 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) {
@@ -2603,7 +2630,6 @@ function mountInstanceInline(instance, target) {
     if (target instanceof Element)
       target.__ASKR_INSTANCE = instance;
   } catch (err) {
-    void err;
   }
   instance.notifyUpdate = instance._enqueueRun;
   const wasFirstMount = !instance.mounted;
@@ -2612,6 +2638,7 @@ function mountInstanceInline(instance, target) {
     executeMountOperations(instance);
   }
 }
+var _globalRenderCounter = 0;
 function runComponent(instance) {
   instance.notifyUpdate = instance._enqueueRun;
   instance._currentRenderToken = ++_globalRenderCounter;
@@ -2633,7 +2660,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 +2680,7 @@ function runComponent(instance) {
           instance.target = host;
           instance._placeholder = void 0;
           host.__ASKR_INSTANCE = instance;
-          finalizeReadSubscriptions(instance);
+          finalizeReadSubscriptions2(instance);
         } finally {
           currentInstance = oldInstance;
         }
@@ -2698,7 +2725,7 @@ function runComponent(instance) {
           } finally {
             currentInstance = oldInstance;
           }
-          finalizeReadSubscriptions(instance);
+          finalizeReadSubscriptions2(instance);
           instance.mounted = true;
           if (wasFirstMount && instance.mountOperations.length > 0) {
             executeMountOperations(instance);
@@ -2717,7 +2744,6 @@ function runComponent(instance) {
               }
             }
           } catch (_err) {
-            void _err;
           }
           try {
             try {
@@ -2750,7 +2776,7 @@ function renderComponentInline(instance) {
   try {
     const result = executeComponentSync(instance);
     if (!hadToken) {
-      finalizeReadSubscriptions(instance);
+      finalizeReadSubscriptions2(instance);
     }
     return result;
   } finally {
@@ -2760,14 +2786,13 @@ function renderComponentInline(instance) {
 }
 function executeComponentSync(instance) {
   instance.stateIndexCheck = -1;
-  for (const state2 of instance.stateValues) {
-    if (state2) {
-      state2._hasBeenRead = false;
+  for (const state of instance.stateValues) {
+    if (state) {
+      state._hasBeenRead = false;
     }
   }
   instance._pendingReadStates = /* @__PURE__ */ new Set();
   currentInstance = instance;
-  stateIndex = 0;
   try {
     const renderStartTime = process.env.NODE_ENV !== "production" ? Date.now() : 0;
     const context = {
@@ -2791,8 +2816,8 @@ function executeComponentSync(instance) {
       instance.firstRenderComplete = true;
     }
     for (let i = 0; i < instance.stateValues.length; i++) {
-      const state2 = instance.stateValues[i];
-      if (state2 && !state2._hasBeenRead) {
+      const state = instance.stateValues[i];
+      if (state && !state._hasBeenRead) {
         try {
           const name = instance.fn?.name || "<anonymous>";
           logger.warn(
@@ -2810,23 +2835,10 @@ function executeComponentSync(instance) {
     currentInstance = null;
   }
 }
-function executeComponent(instance) {
-  instance.abortController = new AbortController();
-  instance.notifyUpdate = instance._enqueueRun;
-  globalScheduler.enqueue(() => runComponent(instance));
-}
 function getCurrentInstance() {
   return currentInstance;
 }
-function getSignal() {
-  if (!currentInstance) {
-    throw new Error(
-      "getSignal() can only be called during component render execution. Ensure you are calling this from inside your component function."
-    );
-  }
-  return currentInstance.abortController.signal;
-}
-function finalizeReadSubscriptions(instance) {
+function finalizeReadSubscriptions2(instance) {
   const newSet = instance._pendingReadStates ?? /* @__PURE__ */ new Set();
   const oldSet = instance._lastReadStates ?? /* @__PURE__ */ new Set();
   const token = instance._currentRenderToken;
@@ -2850,12 +2862,6 @@ function finalizeReadSubscriptions(instance) {
   instance._pendingReadStates = /* @__PURE__ */ new Set();
   instance._currentRenderToken = void 0;
 }
-function getNextStateIndex() {
-  return stateIndex++;
-}
-function mountComponent(instance) {
-  executeComponent(instance);
-}
 function cleanupComponent(instance) {
   const cleanupErrors = [];
   for (const cleanup of instance.cleanupFns) {
@@ -2889,167 +2895,27 @@ function cleanupComponent(instance) {
   instance.notifyUpdate = null;
   instance.mounted = false;
 }
-var currentInstance, stateIndex, _globalRenderCounter;
-var init_component = __esm({
-  "src/runtime/component.ts"() {
-    "use strict";
-    init_scheduler();
-    init_context();
-    init_logger();
-    init_diag();
-    init_fastlane_shared();
-    init_renderer();
-    currentInstance = null;
-    stateIndex = 0;
-    _globalRenderCounter = 0;
-  }
-});
-
-// src/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`);
+// src/runtime/execution-model.ts
+var EXECUTION_MODEL_KEY = /* @__PURE__ */ Symbol.for("__ASKR_EXECUTION_MODEL__");
+function getExecutionModel() {
+  const g = globalThis;
+  return g[EXECUTION_MODEL_KEY];
 }
-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;
-  const normalizedPattern = pattern.endsWith("/") && pattern !== "/" ? pattern.slice(0, -1) : pattern;
-  const pathSegments = normalizedPath.split("/").filter(Boolean);
-  const patternSegments = normalizedPattern.split("/").filter(Boolean);
-  if (patternSegments.length === 1 && patternSegments[0] === "*") {
-    return {
-      matched: true,
-      params: {
-        "*": pathSegments.length > 1 ? normalizedPath : pathSegments[0]
-      }
-    };
-  }
-  if (pathSegments.length !== patternSegments.length) {
-    return { matched: false, params: {} };
-  }
-  const params = {};
-  for (let i = 0; i < patternSegments.length; i++) {
-    const patternSegment = patternSegments[i];
-    const pathSegment = pathSegments[i];
-    if (patternSegment.startsWith("{") && patternSegment.endsWith("}")) {
-      const paramName = patternSegment.slice(1, -1);
-      params[paramName] = decodeURIComponent(pathSegment);
-    } else if (patternSegment === "*") {
-      params["*"] = pathSegment;
-    } else if (patternSegment !== pathSegment) {
-      return { matched: false, params: {} };
-    }
+// src/router/route.ts
+var routes = [];
+var namespaces = /* @__PURE__ */ new Set();
+var HAS_ROUTES_KEY = /* @__PURE__ */ Symbol.for("__ASKR_HAS_ROUTES__");
+function setHasRoutes(value) {
+  try {
+    const g = globalThis;
+    g[HAS_ROUTES_KEY] = value;
+  } catch {
   }
-  return { matched: true, params };
 }
-var init_match = __esm({
-  "src/router/match.ts"() {
-    "use strict";
-  }
-});
-
-// src/router/route.ts
-var route_exports = {};
-__export(route_exports, {
-  _lockRouteRegistrationForTests: () => _lockRouteRegistrationForTests,
-  _unlockRouteRegistrationForTests: () => _unlockRouteRegistrationForTests,
-  clearRoutes: () => clearRoutes,
-  getLoadedNamespaces: () => getLoadedNamespaces,
-  getNamespaceRoutes: () => getNamespaceRoutes,
-  getRoutes: () => getRoutes,
-  lockRouteRegistration: () => lockRouteRegistration,
-  registerRoute: () => registerRoute,
-  resolveRoute: () => resolveRoute,
-  route: () => route,
-  setServerLocation: () => setServerLocation,
-  unloadNamespace: () => unloadNamespace
-});
+setHasRoutes(false);
+var routesByDepth = /* @__PURE__ */ new Map();
 function getDepth(path) {
   const normalized = path.endsWith("/") && path !== "/" ? path.slice(0, -1) : path;
   return normalized === "/" ? 0 : normalized.split("/").filter(Boolean).length;
@@ -3072,6 +2938,7 @@ function getSpecificity(path) {
   }
   return score;
 }
+var serverLocation = null;
 function setServerLocation(url) {
   serverLocation = url;
 }
@@ -3158,6 +3025,7 @@ function computeMatches(pathname) {
     namespace: m.namespace
   }));
 }
+var registrationLocked = false;
 function lockRouteRegistration() {
   registrationLocked = true;
 }
@@ -3168,6 +3036,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 +3083,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 +3093,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) {
@@ -3260,6 +3134,8 @@ function clearRoutes() {
   routes.length = 0;
   namespaces.clear();
   routesByDepth.clear();
+  registrationLocked = false;
+  setHasRoutes(false);
 }
 function normalizeHandler(handler) {
   if (handler == null) return void 0;
@@ -3355,186 +3231,40 @@ function resolveRoute(pathname) {
   }
   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 (owner && owner.mounted === false) {
+        owner = null;
+        pending = void 0;
       }
+      const inst = getCurrentComponentInstance();
+      if (!owner && inst) owner = inst;
       if (process.env.NODE_ENV !== "production") {
         const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
         ns.__PORTAL_READS = (ns.__PORTAL_READS || 0) + 1;
       }
-      if (process.env.NODE_ENV !== "production" && 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;
+      if (process.env.NODE_ENV !== "production") {
+        if (inst && owner && inst !== owner && inst.mounted === true) {
+          logger.warn(
+            "[Portal] multiple mounted hosts detected; first mounted host is owner"
+          );
+        }
       }
-      return inst === owner ? pending : void 0;
+      return inst && owner && inst === owner ? pending : void 0;
     };
-    var HostFallback = HostFallback2;
-    let hosts = [];
+    let owner = null;
     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 (!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;
       }
-      if (owner && owner.notifyUpdate) {
-        if (process.env.NODE_ENV !== "production")
-          logger.debug(
-            "[Portal] fallback.write notify ->",
-            owner.id,
-            !!owner.notifyUpdate
-          );
-        owner.notifyUpdate();
-      }
+      pending = props.children;
+      if (owner.notifyUpdate) owner.notifyUpdate();
       return null;
     };
     return HostFallback2;
@@ -3544,7 +3274,6 @@ function definePortal() {
     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;
@@ -3554,26 +3283,16 @@ function definePortal() {
   };
   return PortalHost;
 }
-function _resetDefaultPortal() {
-  _defaultPortal = void 0;
-  _defaultPortalIsFallback = false;
-}
+var _defaultPortal;
+var _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;
   }
@@ -3586,32 +3305,122 @@ function ensureDefaultPortal() {
     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;
-    })();
+var 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/common/ssr-errors.ts
+var 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);
+  }
+};
+function withSSRContext(ctx, fn) {
+  try {
+    return fn();
+  } finally {
+  }
+}
+function createRenderContext(seed = 12345) {
+  return { seed };
+}
+function runWithSSRContext(ctx, fn) {
+  try {
+    return fn();
+  } finally {
+  }
+}
+function throwSSRDataMissing() {
+  throw new SSRDataMissingError();
+}
+function startRenderPhase(data) {
+}
+var PREPASS_REMOVED_MSG = "SSR collection/prepass is removed: SSR is strictly synchronous";
+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 resolveResources = resolvePlan;
 
 // src/ssr/escape.ts
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var escapeCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 256;
+var TEXT_ESCAPE_TEST_RE = /[&<>]/;
+var TEXT_ESCAPE_RE = /[&<>]/g;
+var ATTR_ESCAPE_TEST_RE = /[&"'<>]/;
+var ATTR_ESCAPE_RE = /[&"'<>]/g;
+var CSS_UNSAFE_TEST_RE = /[{}<>\\]/;
+var CSS_UNSAFE_RE = /[{}<>\\]/g;
+var CSS_DANGEROUS_FN_RE = /(?:url|expression|javascript)\s*\(/i;
+var STYLE_PROP_CACHE = /* @__PURE__ */ new Map();
+var MAX_STYLE_PROP_CACHE_SIZE = 512;
+function toKebabCached(prop) {
+  const cached = STYLE_PROP_CACHE.get(prop);
+  if (cached !== void 0) return cached;
+  const kebab = prop.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+  if (STYLE_PROP_CACHE.size < MAX_STYLE_PROP_CACHE_SIZE) {
+    STYLE_PROP_CACHE.set(prop, kebab);
+  }
+  return kebab;
+}
+function mapTextEscape(ch) {
+  switch (ch) {
+    case "&":
+      return "&amp;";
+    case "<":
+      return "&lt;";
+    default:
+      return "&gt;";
+  }
+}
+function mapAttrEscape(ch) {
+  switch (ch) {
+    case "&":
+      return "&amp;";
+    case '"':
+      return "&quot;";
+    case "'":
+      return "&#x27;";
+    case "<":
+      return "&lt;";
+    default:
+      return "&gt;";
+  }
+}
 function escapeText(text) {
   const useCache = text.length <= 64;
   if (useCache) {
@@ -3619,13 +3428,13 @@ function escapeText(text) {
     if (cached !== void 0) return cached;
   }
   const str = String(text);
-  if (!str.includes("&") && !str.includes("<") && !str.includes(">")) {
+  if (!TEXT_ESCAPE_TEST_RE.test(str)) {
     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;");
+  const result = str.replace(TEXT_ESCAPE_RE, mapTextEscape);
   if (useCache && escapeCache.size < MAX_CACHE_SIZE) {
     escapeCache.set(text, result);
   }
@@ -3633,17 +3442,20 @@ function escapeText(text) {
 }
 function escapeAttr(value) {
   const str = String(value);
-  if (!str.includes("&") && !str.includes('"') && !str.includes("'") && !str.includes("<") && !str.includes(">")) {
+  if (!ATTR_ESCAPE_TEST_RE.test(str)) {
     return str;
   }
-  return str.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return str.replace(ATTR_ESCAPE_RE, mapAttrEscape);
 }
 function escapeCssValue(value) {
   const str = String(value);
-  if (/(?:url|expression|javascript)\s*\(/i.test(str)) {
+  const hasUnsafeChars = CSS_UNSAFE_TEST_RE.test(str);
+  const openParen = str.indexOf("(");
+  if (!hasUnsafeChars && openParen === -1) return str;
+  if (openParen !== -1 && CSS_DANGEROUS_FN_RE.test(str)) {
     return "";
   }
-  return str.replace(/[{}<>\\]/g, "");
+  return hasUnsafeChars ? str.replace(CSS_UNSAFE_RE, "") : str;
 }
 function styleObjToCss(value) {
   if (!value || typeof value !== "object") return null;
@@ -3652,7 +3464,7 @@ function styleObjToCss(value) {
   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 prop = toKebabCached(k);
     const safeValue = escapeCssValue(String(v));
     if (safeValue) {
       out += `${prop}:${safeValue};`;
@@ -3660,30 +3472,6 @@ function styleObjToCss(value) {
   }
   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) {
@@ -3692,8 +3480,11 @@ function renderAttrs(props, opts) {
   }
   let result = "";
   let dangerousHtml;
-  for (const [key, value] of Object.entries(props)) {
+  for (const key in props) {
+    if (!Object.prototype.hasOwnProperty.call(props, key)) continue;
+    const value = props[key];
     if (key === "children") continue;
+    if (key === "key" || key === "ref") continue;
     if (key === "dangerouslySetInnerHTML") {
       if (value && typeof value === "object" && "__html" in value) {
         dangerousHtml = String(value.__html);
@@ -3724,45 +3515,57 @@ function renderAttrs(props, opts) {
   }
   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();
-      }
-    };
+var _StringSink = class _StringSink {
+  constructor() {
+    this.chunks = [];
+    this.bufferChunks = [];
+    this.bufferLen = 0;
   }
-});
+  write(html) {
+    if (!html) return;
+    this.bufferChunks.push(html);
+    this.bufferLen += html.length;
+    if (this.bufferLen >= _StringSink.FLUSH_THRESHOLD) {
+      this.chunks.push(this.bufferChunks.join(""));
+      this.bufferChunks.length = 0;
+      this.bufferLen = 0;
+    }
+  }
+  end() {
+    if (this.bufferLen) {
+      this.chunks.push(this.bufferChunks.join(""));
+      this.bufferChunks.length = 0;
+      this.bufferLen = 0;
+    }
+  }
+  toString() {
+    if (this.bufferLen) {
+      this.chunks.push(this.bufferChunks.join(""));
+      this.bufferChunks.length = 0;
+      this.bufferLen = 0;
+    }
+    return this.chunks.join("");
+  }
+};
+// Reduce array churn by batching many small writes into a larger buffer.
+// This is especially important for large SSR trees where we may write
+// hundreds of thousands of small fragments.
+_StringSink.FLUSH_THRESHOLD = 32 * 1024;
+var StringSink = _StringSink;
+var 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) {
@@ -3790,7 +3593,7 @@ function isPromiseLike(x) {
   const then = x.then;
   return typeof then === "function";
 }
-function executeComponent2(type, props, ctx) {
+function executeComponent(type, props, ctx) {
   const res = type(props ?? {}, { signal: ctx.signal });
   if (isPromiseLike(res)) {
     throwSSRDataMissing();
@@ -3817,7 +3620,7 @@ function renderNodeToSink(node, sink, ctx) {
   if (typeof type === "function") {
     const out = withSSRContext(
       ctx,
-      () => executeComponent2(type, props, ctx)
+      () => executeComponent(type, props, ctx)
     );
     renderNodeToSink(
       out,
@@ -3843,30 +3646,10 @@ function renderNodeToSink(node, 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
-});
+process.env.NODE_ENV !== "production" && (process.env.ASKR_SSR_DEBUG === "1" || process.env.ASKR_SSR_DEBUG === "true");
+var __ssrGuardStack = [];
 function pushSSRStrictPurityGuard() {
   if (process.env.NODE_ENV === "production") return;
   __ssrGuardStack.push({
@@ -3892,65 +3675,80 @@ function popSSRStrictPurityGuard() {
     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);
+function renderChildSyncToSink(child, sink, ctx) {
+  if (child === null || child === void 0 || child === false) return;
+  if (typeof child === "string") {
+    sink.write(escapeText(child));
+    return;
+  }
+  if (typeof child === "number") {
+    sink.write(escapeText(String(child)));
+    return;
+  }
+  if (child && typeof child === "object" && "type" in child) {
+    renderNodeSyncToSink(child, sink, 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 renderChildrenSyncToSink(children, sink, ctx) {
+  if (!children || !Array.isArray(children) || children.length === 0) return;
+  for (let i = 0; i < children.length; i++) {
+    renderChildSyncToSink(children[i], sink, ctx);
+  }
 }
-function renderNodeSync(node, ctx) {
+function renderNodeSyncToSink(node, sink, 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);
+    renderNodeSyncToSink(result, sink, ctx);
+    return;
   }
   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);
+      renderChildrenSyncToSink(childrenArr, sink, ctx);
+      return;
     }
     throw new Error(
-      `renderNodeSync: unsupported VNode symbol type: ${String(type)}`
+      `renderNodeSyncToSink: unsupported VNode symbol type: ${String(type)}`
     );
   }
   const typeStr = type;
   if (VOID_ELEMENTS.has(typeStr)) {
-    const attrs2 = renderAttrs(props);
-    return `<${typeStr}${attrs2} />`;
+    const attrs2 = props ? renderAttrs(props) : "";
+    sink.write(`<${typeStr}${attrs2} />`);
+    return;
   }
-  const { attrs, dangerousHtml } = renderAttrs(props, {
-    returnDangerousHtml: true
-  });
-  if (dangerousHtml !== void 0) {
-    return `<${typeStr}${attrs}>${dangerousHtml}</${typeStr}>`;
+  const maybeDangerous = props ? props?.dangerouslySetInnerHTML : void 0;
+  if (maybeDangerous !== void 0 && maybeDangerous !== null) {
+    const { attrs: attrs2, dangerousHtml } = renderAttrs(props, {
+      returnDangerousHtml: true
+    });
+    sink.write(`<${typeStr}${attrs2}>`);
+    if (dangerousHtml !== void 0) {
+      sink.write(dangerousHtml);
+    } else {
+      renderChildrenSyncToSink(node.children, sink, ctx);
+    }
+    sink.write(`</${typeStr}>`);
+    return;
   }
+  const attrs = props ? renderAttrs(props) : "";
   const children = node.children;
-  const childrenHtml = renderChildrenSync(children, ctx);
-  return `<${typeStr}${attrs}>${childrenHtml}</${typeStr}>`;
+  if (Array.isArray(children) && children.length === 1) {
+    const only = children[0];
+    if (typeof only === "string") {
+      sink.write(`<${typeStr}${attrs}>${escapeText(only)}</${typeStr}>`);
+      return;
+    }
+    if (typeof only === "number") {
+      const escaped = escapeText(String(only));
+      sink.write(`<${typeStr}${attrs}>${escaped}</${typeStr}>`);
+      return;
+    }
+  }
+  sink.write(`<${typeStr}${attrs}>`);
+  renderChildrenSyncToSink(children, sink, ctx);
+  sink.write(`</${typeStr}>`);
 }
 function executeComponentSync2(component, props, ctx) {
   try {
@@ -4019,9 +3817,11 @@ function renderToStringSync(component, props, options) {
     if (!node) {
       throw new Error("renderToStringSync: wrapped component returned empty");
     }
-    return renderNodeSync(node, ctx);
+    const sink = new StringSink();
+    renderNodeSyncToSink(node, sink, ctx);
+    sink.end();
+    return sink.toString();
   } finally {
-    stopRenderPhase();
   }
 }
 function renderToStringSyncForUrl(opts) {
@@ -4068,9 +3868,11 @@ function renderToStringSyncForUrl(opts) {
       };
     };
     const node = executeComponentSync2(wrapped, resolved.params || {}, ctx);
-    return renderNodeSync(node, ctx);
+    const sink = new StringSink();
+    renderNodeSyncToSink(node, sink, ctx);
+    sink.end();
+    return sink.toString();
   } finally {
-    stopRenderPhase();
   }
 }
 function renderToString(arg) {
@@ -4113,1079 +3915,12 @@ function renderToSinkInternal(opts) {
     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?.();
-        });
-    }
-  };
-  return read;
-}
-
-// src/index.ts
-init_component();
-init_scheduler();
-init_context();
-
-// src/runtime/operations.ts
-init_component();
-init_context();
-
-// src/runtime/resource-cell.ts
-init_context();
-init_logger();
-init_context2();
-var ResourceCell = class {
-  constructor(fn, deps, resourceFrame) {
-    this.value = null;
-    this.pending = true;
-    this.error = null;
-    this.generation = 0;
-    this.controller = null;
-    this.deps = null;
-    this.resourceFrame = null;
-    this.subscribers = /* @__PURE__ */ new Set();
-    this.fn = fn;
-    this.deps = deps ? deps.slice() : null;
-    this.resourceFrame = resourceFrame;
-    this.snapshot = {
-      value: null,
-      pending: true,
-      error: null,
-      refresh: () => this.refresh()
-    };
-  }
-  subscribe(cb) {
-    this.subscribers.add(cb);
-    return () => this.subscribers.delete(cb);
-  }
-  notifySubscribers() {
-    this.snapshot.value = this.value;
-    this.snapshot.pending = this.pending;
-    this.snapshot.error = this.error;
-    for (const cb of this.subscribers) cb();
-  }
-  start(ssr = false, notify = true) {
-    const generation = this.generation;
-    this.controller?.abort();
-    const controller = new AbortController();
-    this.controller = controller;
-    this.pending = true;
-    this.error = null;
-    if (notify) this.notifySubscribers();
-    let result;
-    try {
-      result = withAsyncResourceContext(
-        this.resourceFrame,
-        () => this.fn({ signal: controller.signal })
-      );
-    } catch (err) {
-      this.pending = false;
-      this.error = err;
-      if (notify) this.notifySubscribers();
-      return;
-    }
-    if (!(result instanceof Promise)) {
-      this.value = result;
-      this.pending = false;
-      this.error = null;
-      if (notify) this.notifySubscribers();
-      return;
-    }
-    if (ssr) {
-      throwSSRDataMissing();
-    }
-    result.then((val) => {
-      if (this.generation !== generation) return;
-      if (this.controller !== controller) return;
-      this.value = val;
-      this.pending = false;
-      this.error = null;
-      this.notifySubscribers();
-    }).catch((err) => {
-      if (this.generation !== generation) return;
-      this.pending = false;
-      this.error = err;
-      try {
-        if (this.ownerName) {
-          logger.error(
-            `[Askr] Async resource error in ${this.ownerName}:`,
-            err
-          );
-        } else {
-          logger.error("[Askr] Async resource error:", err);
-        }
-      } catch {
-      }
-      this.notifySubscribers();
-    });
-  }
-  refresh() {
-    this.generation++;
-    this.controller?.abort();
-    this.start();
-  }
-  abort() {
-    this.controller?.abort();
-  }
-};
-
-// src/shared/derive-cache.ts
-var deriveCacheMap = /* @__PURE__ */ new WeakMap();
-function getDeriveCache(instance) {
-  let cache = deriveCacheMap.get(instance);
-  if (!cache) {
-    cache = /* @__PURE__ */ new Map();
-    deriveCacheMap.set(instance, cache);
-  }
-  return cache;
-}
-
-// src/runtime/operations.ts
-init_context2();
-init_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: () => {
-      }
-    };
-  }
-  const renderData = getCurrentRenderData();
-  if (renderData) {
-    const key = getNextKey();
-    if (!(key in renderData)) {
-      throwSSRDataMissing();
-    }
-    const val = renderData[key];
-    const holder2 = state({
-      cell: void 0,
-      snapshot: {
-        value: val,
-        pending: false,
-        error: null,
-        refresh: () => {
-        }
-      }
-    });
-    const h2 = holder2();
-    h2.snapshot.value = val;
-    h2.snapshot.pending = false;
-    h2.snapshot.error = null;
-    holder2.set(h2);
-    return h2.snapshot;
-  }
-  const holder = state({
-    cell: void 0,
-    snapshot: {
-      value: null,
-      pending: true,
-      error: null,
-      refresh: () => {
-      }
-    }
-  });
-  const h = holder();
-  if (!h.cell) {
-    const frame = getCurrentContextFrame();
-    const cell2 = new ResourceCell(fn, deps, frame);
-    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 {
-      }
-    });
-    inst.cleanupFns.push(() => {
-      unsubscribe();
-      cell2.abort();
-    });
-    try {
-      cell2.start(inst.ssr ?? false, false);
-      if (!cell2.pending) {
-        const cur = holder();
-        cur.snapshot.value = cell2.value;
-        cur.snapshot.pending = cell2.pending;
-        cur.snapshot.error = cell2.error;
-      }
-    } catch (err) {
-      if (err instanceof SSRDataMissingError) throw err;
-      cell2.error = err;
-      cell2.pending = false;
-      const cur = holder();
-      cur.snapshot.value = cell2.value;
-      cur.snapshot.pending = cell2.pending;
-      cur.snapshot.error = cell2.error;
-    }
-  }
-  const cell = h.cell;
-  const depsChanged = !cell.deps || cell.deps.length !== deps.length || cell.deps.some((d, i) => d !== deps[i]);
-  if (depsChanged) {
-    cell.deps = deps.slice();
-    cell.generation++;
-    cell.pending = true;
-    cell.error = null;
-    try {
-      cell.start(inst.ssr ?? false, false);
-      if (!cell.pending) {
-        const cur = holder();
-        cur.snapshot.value = cell.value;
-        cur.snapshot.pending = cell.pending;
-        cur.snapshot.error = cell.error;
-      }
-    } catch (err) {
-      if (err instanceof SSRDataMissingError) throw err;
-      cell.error = err;
-      cell.pending = false;
-      const cur = holder();
-      cur.snapshot.value = cell.value;
-      cur.snapshot.pending = cell.pending;
-      cur.snapshot.error = cell.error;
-    }
-  }
-  return h.snapshot;
-}
-function derive(source, map) {
-  if (map === void 0 && typeof source === "function") {
-    const value2 = source();
-    if (value2 == null) return null;
-    const instance2 = getCurrentComponentInstance();
-    if (!instance2) {
-      return value2;
-    }
-    const cache2 = getDeriveCache(instance2);
-    if (cache2.has(value2)) return cache2.get(value2);
-    cache2.set(value2, value2);
-    return value2;
-  }
-  let value;
-  if (typeof source === "function" && !("value" in source)) {
-    value = source();
-  } else {
-    value = source?.value ?? source;
   }
-  if (value == null) return null;
-  const instance = getCurrentComponentInstance();
-  if (!instance) {
-    return map(value);
-  }
-  const cache = getDeriveCache(instance);
-  if (cache.has(value)) {
-    return cache.get(value);
-  }
-  const result = map(value);
-  cache.set(value, result);
-  return result;
-}
-function task(fn) {
-  const ownerIsRoot = getCurrentComponentInstance()?.isRoot ?? false;
-  registerMountOperation(async () => {
-    if (!ownerIsRoot) {
-      throw new Error("[Askr] task() may only be used in root components");
-    }
-    return await fn();
-  });
 }
 
-// src/boot/index.ts
-init_component();
-init_scheduler();
-init_logger();
-init_navigate();
-init_jsx();
-init_portal();
-init_renderer();
-var componentIdCounter = 0;
-var instancesByRoot = /* @__PURE__ */ new WeakMap();
-var CLEANUP_SYMBOL = /* @__PURE__ */ Symbol.for("__tempoCleanup__");
-function attachCleanupForRoot(rootElement, instance) {
-  rootElement[CLEANUP_SYMBOL] = () => {
-    const errors = [];
-    try {
-      removeAllListeners(rootElement);
-    } catch (e) {
-      errors.push(e);
-    }
-    try {
-      const descendants = rootElement.querySelectorAll("*");
-      for (const d of Array.from(descendants)) {
-        try {
-          const inst = d.__ASKR_INSTANCE;
-          if (inst) {
-            try {
-              cleanupComponent(inst);
-            } catch (err) {
-              errors.push(err);
-            }
-            try {
-              delete d.__ASKR_INSTANCE;
-            } catch (err) {
-              errors.push(err);
-            }
-          }
-        } catch (err) {
-          errors.push(err);
-        }
-      }
-    } catch (e) {
-      errors.push(e);
-    }
-    try {
-      cleanupComponent(instance);
-    } catch (e) {
-      errors.push(e);
-    }
-    if (errors.length > 0) {
-      if (instance.cleanupStrict) {
-        throw new AggregateError(errors, `cleanup failed for app root`);
-      } else if (process.env.NODE_ENV !== "production") {
-        for (const err of errors) logger.warn("[Askr] cleanup error:", err);
-      }
-    }
-  };
-  try {
-    const descriptor = Object.getOwnPropertyDescriptor(rootElement, "innerHTML") || Object.getOwnPropertyDescriptor(
-      Object.getPrototypeOf(rootElement),
-      "innerHTML"
-    ) || Object.getOwnPropertyDescriptor(Element.prototype, "innerHTML");
-    if (descriptor && (descriptor.get || descriptor.set)) {
-      Object.defineProperty(rootElement, "innerHTML", {
-        get: descriptor.get ? function() {
-          return descriptor.get.call(this);
-        } : void 0,
-        set: function(value) {
-          if (value === "" && instancesByRoot.get(this) === instance) {
-            try {
-              removeAllListeners(rootElement);
-            } catch (e) {
-              if (instance.cleanupStrict) throw e;
-              if (process.env.NODE_ENV !== "production")
-                logger.warn("[Askr] cleanup error:", e);
-            }
-            try {
-              cleanupComponent(instance);
-            } catch (e) {
-              if (instance.cleanupStrict) throw e;
-              if (process.env.NODE_ENV !== "production")
-                logger.warn("[Askr] cleanup error:", e);
-            }
-          }
-          if (descriptor.set) {
-            return descriptor.set.call(this, value);
-          }
-        },
-        configurable: true
-      });
-    }
-  } catch {
-  }
-}
-function mountOrUpdate(rootElement, componentFn, options) {
-  const wrappedFn = (props, ctx) => {
-    const out = componentFn(props, ctx);
-    const portalVNode = {
-      $$typeof: ELEMENT_TYPE,
-      type: DefaultPortal,
-      props: {},
-      key: "__default_portal"
-    };
-    return {
-      $$typeof: ELEMENT_TYPE,
-      type: Fragment,
-      props: {
-        children: out === void 0 || out === null ? [portalVNode] : [out, portalVNode]
-      }
-    };
-  };
-  Object.defineProperty(wrappedFn, "name", {
-    value: componentFn.name || "Component"
-  });
-  const existingCleanup = rootElement[CLEANUP_SYMBOL];
-  if (existingCleanup) existingCleanup();
-  let instance = instancesByRoot.get(rootElement);
-  if (instance) {
-    removeAllListeners(rootElement);
-    try {
-      cleanupComponent(instance);
-    } catch (e) {
-      if (process.env.NODE_ENV !== "production")
-        logger.warn("[Askr] prior cleanup threw:", e);
-    }
-    instance.fn = wrappedFn;
-    instance.evaluationGeneration++;
-    instance.mounted = false;
-    instance.expectedStateIndices = [];
-    instance.firstRenderComplete = false;
-    instance.isRoot = true;
-    if (options && typeof options.cleanupStrict === "boolean") {
-      instance.cleanupStrict = options.cleanupStrict;
-    }
-  } else {
-    const componentId = String(++componentIdCounter);
-    instance = createComponentInstance(componentId, wrappedFn, {}, rootElement);
-    instancesByRoot.set(rootElement, instance);
-    instance.isRoot = true;
-    if (options && typeof options.cleanupStrict === "boolean") {
-      instance.cleanupStrict = options.cleanupStrict;
-    }
-  }
-  attachCleanupForRoot(rootElement, instance);
-  mountComponent(instance);
-  globalScheduler.flush();
-}
-function createIsland(config) {
-  if (!config || typeof config !== "object") {
-    throw new Error("createIsland requires a config object");
-  }
-  if (typeof config.component !== "function") {
-    throw new Error("createIsland: component must be a function");
-  }
-  const rootElement = typeof config.root === "string" ? document.getElementById(config.root) : config.root;
-  if (!rootElement) throw new Error(`Root element not found: ${config.root}`);
-  if ("routes" in config) {
-    throw new Error(
-      "createIsland does not accept routes; use createSPA for routed apps"
-    );
-  }
-  mountOrUpdate(rootElement, config.component, {
-    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();
-  }
-  if (process.env.NODE_ENV !== "production") {
-    if (isBulkCommitActive2()) {
-      throw new Error(
-        "Fast-lane invariant violated: bulk commit flag still set after commit"
-      );
-    }
-  }
-}
-function validateFastLaneInvariants(instance, schedBefore) {
-  const commitCount = getDevValue("__LAST_FASTPATH_COMMIT_COUNT") ?? 0;
-  const invariants = {
-    commitCount,
-    mountOps: instance.mountOperations.length,
-    cleanupFns: instance.cleanupFns.length
-  };
-  setDevValue("__LAST_FASTLANE_INVARIANTS", invariants);
-  if (commitCount !== 1) {
-    console.error(
-      "[FASTLANE][INV] commitCount",
-      commitCount,
-      "diag",
-      globalThis.__ASKR_DIAG
-    );
-    throw new Error(
-      "Fast-lane invariant violated: expected exactly one DOM commit during reorder-only commit"
-    );
-  }
-  if (invariants.mountOps > 0) {
-    throw new Error(
-      "Fast-lane invariant violated: mount operations were registered during bulk commit"
-    );
-  }
-  if (invariants.cleanupFns > 0) {
-    throw new Error(
-      "Fast-lane invariant violated: cleanup functions were added during bulk commit"
-    );
-  }
-  const schedAfter = globalScheduler.getState();
-  if (schedBefore && schedAfter && schedAfter.taskCount > schedBefore.taskCount) {
-    console.error(
-      "[FASTLANE] schedBefore, schedAfter",
-      schedBefore,
-      schedAfter
-    );
-    console.error("[FASTLANE] enqueue logs", getDevValue("__ENQUEUE_LOGS"));
-    throw new Error(
-      "Fast-lane invariant violated: scheduler enqueued leftover work during bulk commit"
-    );
-  }
-  let finalState = globalScheduler.getState();
-  const executing = globalScheduler.isExecuting();
-  let outstandingAfter = Math.max(
-    0,
-    finalState.taskCount - (executing ? 1 : 0)
-  );
-  if (outstandingAfter !== 0) {
-    let attempts = 0;
-    while (attempts < 5) {
-      const cleared = globalScheduler.clearPendingSyncTasks?.() ?? 0;
-      if (cleared === 0) break;
-      attempts++;
-    }
-    finalState = globalScheduler.getState();
-    outstandingAfter = Math.max(
-      0,
-      finalState.taskCount - (globalScheduler.isExecuting() ? 1 : 0)
-    );
-    if (outstandingAfter !== 0) {
-      console.error(
-        "[FASTLANE] Post-commit enqueue logs:",
-        getDevValue("__ENQUEUE_LOGS")
-      );
-      console.error(
-        "[FASTLANE] Cleared counts:",
-        getDevValue("__FASTLANE_CLEARED_TASKS"),
-        getDevValue("__FASTLANE_CLEARED_AFTER")
-      );
-      throw new Error(
-        `Fast-lane invariant violated: scheduler has ${finalState.taskCount} pending task(s) after commit`
-      );
-    }
-  }
-}
-function tryRuntimeFastLaneSync(instance, result) {
-  const cls = classifyUpdate(instance, result);
-  if (!cls.useFastPath) {
-    setDevValue("__LAST_FASTPATH_STATS", void 0);
-    setDevValue("__LAST_FASTPATH_COMMIT_COUNT", 0);
-    return false;
-  }
-  try {
-    return commitReorderOnly(instance, result);
-  } catch (err) {
-    if (process.env.NODE_ENV !== "production") throw err;
-    return false;
-  }
-}
-if (typeof globalThis !== "undefined") {
-  globalThis.__ASKR_FASTLANE = {
-    isBulkCommitActive: isBulkCommitActive2,
-    enterBulkCommit,
-    exitBulkCommit,
-    tryRuntimeFastLaneSync,
-    markFastPathApplied,
-    isFastPathApplied
-  };
-}
-
-// 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;
-}
-// 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
-});
-//# sourceMappingURL=index.cjs.map
+export { SSRDataMissingError, collectResources, popSSRStrictPurityGuard, pushSSRStrictPurityGuard, renderToStream, renderToString, renderToStringSync, renderToStringSyncForUrl, resolvePlan, resolveResources };
+//# sourceMappingURL=ssr.js.map
+//# sourceMappingURL=ssr.js.map