@askrjs/askr 0.0.2 → 0.0.4

package/dist/resources/index.cjs

@@ -0,0 +1,1200 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/resources/index.ts
+var resources_exports = {};
+__export(resources_exports, {
+  resource: () => resource
+});
+module.exports = __toCommonJS(resources_exports);
+
+// src/dev/invariant.ts
+function invariant(condition, message, context) {
+  if (!condition) {
+    const contextStr = context ? "\n" + JSON.stringify(context, null, 2) : "";
+    throw new Error(`[Askr Invariant] ${message}${contextStr}`);
+  }
+}
+function assertSchedulingPrecondition(condition, violationMessage) {
+  invariant(condition, `[Scheduler Precondition] ${violationMessage}`);
+}
+
+// src/dev/logger.ts
+function callConsole(method, args) {
+  const c = typeof console !== "undefined" ? console : void 0;
+  if (!c) return;
+  const fn = c[method];
+  if (typeof fn === "function") {
+    try {
+      fn.apply(console, args);
+    } catch {
+    }
+  }
+}
+var logger = {
+  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;
+  }
+}
+var Scheduler = class {
+  constructor() {
+    this.q = [];
+    this.head = 0;
+    this.running = false;
+    this.inHandler = false;
+    this.depth = 0;
+    this.executionDepth = 0;
+    // for compat with existing diagnostics
+    // Monotonic flush version increments at end of each flush
+    this.flushVersion = 0;
+    // Best-effort microtask kick scheduling
+    this.kickScheduled = false;
+    // Escape hatch flag for runWithSyncProgress
+    this.allowSyncProgress = false;
+    // Waiters waiting for flushVersion >= target
+    this.waiters = [];
+    // Keep a lightweight taskCount for compatibility/diagnostics
+    this.taskCount = 0;
+  }
+  enqueue(task) {
+    assertSchedulingPrecondition(
+      typeof task === "function",
+      "enqueue() requires a function"
+    );
+    if (isBulkCommitActive() && !this.allowSyncProgress) {
+      if (process.env.NODE_ENV !== "production") {
+        throw new Error(
+          "[Scheduler] enqueue() during bulk commit (not allowed)"
+        );
+      }
+      return;
+    }
+    this.q.push(task);
+    this.taskCount++;
+    if (!this.running && !this.kickScheduled && !this.inHandler && !isBulkCommitActive()) {
+      this.kickScheduled = true;
+      queueMicrotask(() => {
+        this.kickScheduled = false;
+        if (this.running) return;
+        if (isBulkCommitActive()) return;
+        try {
+          this.flush();
+        } catch (err) {
+          setTimeout(() => {
+            throw err;
+          });
+        }
+      });
+    }
+  }
+  flush() {
+    invariant(
+      !this.running,
+      "[Scheduler] flush() called while already running"
+    );
+    if (process.env.NODE_ENV !== "production") {
+      if (isBulkCommitActive() && !this.allowSyncProgress) {
+        throw new Error(
+          "[Scheduler] flush() started during bulk commit (not allowed)"
+        );
+      }
+    }
+    this.running = true;
+    this.depth = 0;
+    let fatal = null;
+    try {
+      while (this.head < this.q.length) {
+        this.depth++;
+        if (process.env.NODE_ENV !== "production" && this.depth > MAX_FLUSH_DEPTH) {
+          throw new Error(
+            `[Scheduler] exceeded MAX_FLUSH_DEPTH (${MAX_FLUSH_DEPTH}). Likely infinite update loop.`
+          );
+        }
+        const task = this.q[this.head++];
+        try {
+          this.executionDepth++;
+          task();
+          this.executionDepth--;
+        } catch (err) {
+          if (this.executionDepth > 0) this.executionDepth = 0;
+          fatal = err;
+          break;
+        }
+        if (this.taskCount > 0) this.taskCount--;
+      }
+    } finally {
+      this.running = false;
+      this.depth = 0;
+      this.executionDepth = 0;
+      if (this.head >= this.q.length) {
+        this.q.length = 0;
+        this.head = 0;
+      } else if (this.head > 0) {
+        const remaining = this.q.length - this.head;
+        for (let i = 0; i < remaining; i++) {
+          this.q[i] = this.q[this.head + i];
+        }
+        this.q.length = remaining;
+        this.head = 0;
+      }
+      this.flushVersion++;
+      this.resolveWaiters();
+    }
+    if (fatal) throw fatal;
+  }
+  runWithSyncProgress(fn) {
+    const prev = this.allowSyncProgress;
+    this.allowSyncProgress = true;
+    const g = globalThis;
+    const origQueueMicrotask = g.queueMicrotask;
+    const origSetTimeout = g.setTimeout;
+    if (process.env.NODE_ENV !== "production") {
+      g.queueMicrotask = () => {
+        throw new Error(
+          "[Scheduler] queueMicrotask not allowed during runWithSyncProgress"
+        );
+      };
+      g.setTimeout = () => {
+        throw new Error(
+          "[Scheduler] setTimeout not allowed during runWithSyncProgress"
+        );
+      };
+    }
+    const startVersion = this.flushVersion;
+    try {
+      const res = fn();
+      if (!this.running && this.q.length - this.head > 0) {
+        this.flush();
+      }
+      if (process.env.NODE_ENV !== "production") {
+        if (this.q.length - this.head > 0) {
+          throw new Error(
+            "[Scheduler] tasks remain after runWithSyncProgress flush"
+          );
+        }
+      }
+      return res;
+    } finally {
+      if (process.env.NODE_ENV !== "production") {
+        g.queueMicrotask = origQueueMicrotask;
+        g.setTimeout = origSetTimeout;
+      }
+      try {
+        if (this.flushVersion === startVersion) {
+          this.flushVersion++;
+          this.resolveWaiters();
+        }
+      } catch (e) {
+        void e;
+      }
+      this.allowSyncProgress = prev;
+    }
+  }
+  waitForFlush(targetVersion, timeoutMs = 2e3) {
+    const target = typeof targetVersion === "number" ? targetVersion : this.flushVersion + 1;
+    if (this.flushVersion >= target) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        const ns = globalThis.__ASKR__ || {};
+        const diag = {
+          flushVersion: this.flushVersion,
+          queueLen: this.q.length - this.head,
+          running: this.running,
+          inHandler: this.inHandler,
+          bulk: isBulkCommitActive(),
+          namespace: ns
+        };
+        reject(
+          new Error(
+            `waitForFlush timeout ${timeoutMs}ms: ${JSON.stringify(diag)}`
+          )
+        );
+      }, timeoutMs);
+      this.waiters.push({ target, resolve, reject, timer });
+    });
+  }
+  getState() {
+    return {
+      queueLength: this.q.length - this.head,
+      running: this.running,
+      depth: this.depth,
+      executionDepth: this.executionDepth,
+      taskCount: this.taskCount,
+      flushVersion: this.flushVersion,
+      // New fields for optional inspection
+      inHandler: this.inHandler,
+      allowSyncProgress: this.allowSyncProgress
+    };
+  }
+  setInHandler(v) {
+    this.inHandler = v;
+  }
+  isInHandler() {
+    return this.inHandler;
+  }
+  isExecuting() {
+    return this.running || this.executionDepth > 0;
+  }
+  // Clear pending synchronous tasks (used by fastlane enter/exit)
+  clearPendingSyncTasks() {
+    const remaining = this.q.length - this.head;
+    if (remaining <= 0) return 0;
+    if (this.running) {
+      this.q.length = this.head;
+      this.taskCount = Math.max(0, this.taskCount - remaining);
+      queueMicrotask(() => {
+        try {
+          this.flushVersion++;
+          this.resolveWaiters();
+        } catch (e) {
+          void e;
+        }
+      });
+      return remaining;
+    }
+    this.q.length = 0;
+    this.head = 0;
+    this.taskCount = Math.max(0, this.taskCount - remaining);
+    this.flushVersion++;
+    this.resolveWaiters();
+    return remaining;
+  }
+  resolveWaiters() {
+    if (this.waiters.length === 0) return;
+    const ready = [];
+    const remaining = [];
+    for (const w of this.waiters) {
+      if (this.flushVersion >= w.target) {
+        if (w.timer) clearTimeout(w.timer);
+        ready.push(w.resolve);
+      } else {
+        remaining.push(w);
+      }
+    }
+    this.waiters = remaining;
+    for (const r of ready) r();
+  }
+};
+var globalScheduler = new Scheduler();
+
+// src/runtime/context.ts
+var currentContextFrame = null;
+var currentAsyncResourceFrame = null;
+function withAsyncResourceContext(frame, fn) {
+  const oldFrame = currentAsyncResourceFrame;
+  currentAsyncResourceFrame = frame;
+  try {
+    return fn();
+  } finally {
+    currentAsyncResourceFrame = oldFrame;
+  }
+}
+function getCurrentContextFrame() {
+  return currentContextFrame;
+}
+
+// src/renderer/utils.ts
+function isIgnoredForPropChanges(key) {
+  if (key === "children" || key === "key") return true;
+  if (key.startsWith("on") && key.length > 2) return true;
+  if (key.startsWith("data-")) return true;
+  return false;
+}
+function hasPropChanged(el, key, value) {
+  try {
+    if (key === "class" || key === "className") {
+      return el.className !== String(value);
+    }
+    if (key === "value" || key === "checked") {
+      return el[key] !== value;
+    }
+    const attr = el.getAttribute(key);
+    if (value === void 0 || value === null || value === false) {
+      return attr !== null;
+    }
+    return String(value) !== attr;
+  } catch {
+    return true;
+  }
+}
+function hasNonTrivialProps(props) {
+  for (const k of Object.keys(props)) {
+    if (isIgnoredForPropChanges(k)) continue;
+    return true;
+  }
+  return false;
+}
+function extractKey(vnode) {
+  if (typeof vnode !== "object" || vnode === null) return void 0;
+  const obj = vnode;
+  const rawKey = obj.key ?? obj.props?.key;
+  if (rawKey === void 0) return void 0;
+  return typeof rawKey === "symbol" ? String(rawKey) : rawKey;
+}
+function buildKeyMapFromChildren(parent) {
+  const map = /* @__PURE__ */ new Map();
+  for (let ch = parent.firstElementChild; ch; ch = ch.nextElementSibling) {
+    const k = ch.getAttribute("data-key");
+    if (k !== null) {
+      map.set(k, ch);
+      const n = Number(k);
+      if (!Number.isNaN(n)) map.set(n, ch);
+    }
+  }
+  return map;
+}
+
+// src/renderer/keyed.ts
+var keyedElements = /* @__PURE__ */ new WeakMap();
+function getKeyMapForElement(el) {
+  return keyedElements.get(el);
+}
+function populateKeyMapForElement(parent) {
+  try {
+    if (keyedElements.has(parent)) return;
+    let domMap = buildKeyMapFromChildren(parent);
+    if (domMap.size === 0) {
+      domMap = /* @__PURE__ */ new Map();
+      const children = Array.from(parent.children);
+      for (const ch of children) {
+        const text = (ch.textContent || "").trim();
+        if (text) {
+          domMap.set(text, ch);
+          const n = Number(text);
+          if (!Number.isNaN(n)) domMap.set(n, ch);
+        }
+      }
+    }
+    if (domMap.size > 0) keyedElements.set(parent, domMap);
+  } catch {
+  }
+}
+function extractKeyedVnodes(newChildren) {
+  const result = [];
+  for (const child of newChildren) {
+    const key = extractKey(child);
+    if (key !== void 0) {
+      result.push({ key, vnode: child });
+    }
+  }
+  return result;
+}
+function computeLISLength(positions) {
+  const tails = [];
+  for (const pos of positions) {
+    if (pos === -1) continue;
+    let lo = 0;
+    let hi = tails.length;
+    while (lo < hi) {
+      const mid = lo + hi >> 1;
+      if (tails[mid] < pos) lo = mid + 1;
+      else hi = mid;
+    }
+    if (lo === tails.length) tails.push(pos);
+    else tails[lo] = pos;
+  }
+  return tails.length;
+}
+function checkVnodesHaveProps(keyedVnodes) {
+  for (const { vnode } of keyedVnodes) {
+    if (typeof vnode !== "object" || vnode === null) continue;
+    const vnodeObj = vnode;
+    if (vnodeObj.props && hasNonTrivialProps(vnodeObj.props)) {
+      return true;
+    }
+  }
+  return false;
+}
+function checkVnodePropChanges(keyedVnodes, oldKeyMap) {
+  for (const { key, vnode } of keyedVnodes) {
+    const el = oldKeyMap?.get(key);
+    if (!el || typeof vnode !== "object" || vnode === null) continue;
+    const vnodeObj = vnode;
+    const props = vnodeObj.props || {};
+    for (const k of Object.keys(props)) {
+      if (isIgnoredForPropChanges(k)) continue;
+      if (hasPropChanged(el, k, props[k])) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function isKeyedReorderFastPathEligible(parent, newChildren, oldKeyMap) {
+  const keyedVnodes = extractKeyedVnodes(newChildren);
+  const totalKeyed = keyedVnodes.length;
+  const newKeyOrder = keyedVnodes.map((kv) => kv.key);
+  const oldKeyOrder = oldKeyMap ? Array.from(oldKeyMap.keys()) : [];
+  let moveCount = 0;
+  for (let i = 0; i < newKeyOrder.length; i++) {
+    const k = newKeyOrder[i];
+    if (i >= oldKeyOrder.length || oldKeyOrder[i] !== k || !oldKeyMap?.has(k)) {
+      moveCount++;
+    }
+  }
+  const FAST_MOVE_THRESHOLD_ABS = 64;
+  const FAST_MOVE_THRESHOLD_REL = 0.1;
+  const cheapMoveTrigger = totalKeyed >= 128 && oldKeyOrder.length > 0 && moveCount > Math.max(
+    FAST_MOVE_THRESHOLD_ABS,
+    Math.floor(totalKeyed * FAST_MOVE_THRESHOLD_REL)
+  );
+  let lisTrigger = false;
+  let lisLen = 0;
+  if (totalKeyed >= 128) {
+    const parentChildren = Array.from(parent.children);
+    const positions = keyedVnodes.map(({ key }) => {
+      const el = oldKeyMap?.get(key);
+      return el?.parentElement === parent ? parentChildren.indexOf(el) : -1;
+    });
+    lisLen = computeLISLength(positions);
+    lisTrigger = lisLen < Math.floor(totalKeyed * 0.5);
+  }
+  const hasPropsPresent = checkVnodesHaveProps(keyedVnodes);
+  const hasPropChanges = checkVnodePropChanges(keyedVnodes, oldKeyMap);
+  const useFastPath = (cheapMoveTrigger || lisTrigger) && !hasPropChanges && !hasPropsPresent;
+  return {
+    useFastPath,
+    totalKeyed,
+    moveCount,
+    lisLen,
+    hasPropChanges
+  };
+}
+
+// src/common/jsx.ts
+var Fragment = /* @__PURE__ */ Symbol.for("askr.fragment");
+
+// src/runtime/dev-namespace.ts
+function getDevNamespace() {
+  if (process.env.NODE_ENV === "production") return {};
+  try {
+    const g = globalThis;
+    if (!g.__ASKR__) g.__ASKR__ = {};
+    return g.__ASKR__;
+  } catch {
+    return {};
+  }
+}
+function setDevValue(key, value) {
+  if (process.env.NODE_ENV === "production") return;
+  try {
+    getDevNamespace()[key] = value;
+  } catch {
+  }
+}
+function getDevValue(key) {
+  if (process.env.NODE_ENV === "production") return void 0;
+  try {
+    return getDevNamespace()[key];
+  } catch {
+    return void 0;
+  }
+}
+
+// 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;
+  }
+}
+function exitBulkCommit() {
+  _bulkCommitActive = false;
+  _appliedParents = null;
+}
+function isBulkCommitActive2() {
+  return _bulkCommitActive;
+}
+function markFastPathApplied(parent) {
+  if (!_appliedParents) return;
+  try {
+    _appliedParents.add(parent);
+  } catch (e) {
+    void e;
+  }
+}
+function isFastPathApplied(parent) {
+  return !!(_appliedParents && _appliedParents.has(parent));
+}
+function finalizeReadSubscriptions(instance) {
+  const newSet = instance._pendingReadStates ?? /* @__PURE__ */ new Set();
+  const oldSet = instance._lastReadStates ?? /* @__PURE__ */ new Set();
+  const token = instance._currentRenderToken;
+  if (token === void 0) return;
+  for (const s of oldSet) {
+    if (!newSet.has(s)) {
+      const readers = s._readers;
+      if (readers) readers.delete(instance);
+    }
+  }
+  instance.lastRenderToken = token;
+  for (const s of newSet) {
+    let readers = s._readers;
+    if (!readers) {
+      readers = /* @__PURE__ */ new Map();
+      s._readers = readers;
+    }
+    readers.set(instance, instance.lastRenderToken ?? 0);
+  }
+  instance._lastReadStates = newSet;
+  instance._pendingReadStates = /* @__PURE__ */ new Set();
+  instance._currentRenderToken = void 0;
+}
+function unwrapFragmentForFastPath(vnode) {
+  if (!vnode || typeof vnode !== "object" || !("type" in vnode)) return vnode;
+  const v = vnode;
+  if (typeof v.type === "symbol" && (v.type === Fragment || String(v.type) === "Symbol(askr.fragment)")) {
+    const children = v.children || v.props?.children;
+    if (Array.isArray(children) && children.length > 0) {
+      for (const child of children) {
+        if (child && typeof child === "object" && "type" in child) {
+          const c = child;
+          if (typeof c.type === "string") {
+            return child;
+          }
+        }
+      }
+    }
+  }
+  return vnode;
+}
+function classifyUpdate(instance, result) {
+  const unwrappedResult = unwrapFragmentForFastPath(result);
+  if (!unwrappedResult || typeof unwrappedResult !== "object" || !("type" in unwrappedResult))
+    return { useFastPath: false, reason: "not-vnode" };
+  const vnode = unwrappedResult;
+  if (vnode == null || typeof vnode.type !== "string")
+    return { useFastPath: false, reason: "not-intrinsic" };
+  const parent = instance.target;
+  if (!parent) return { useFastPath: false, reason: "no-root" };
+  const firstChild = parent.children[0];
+  if (!firstChild) return { useFastPath: false, reason: "no-first-child" };
+  if (firstChild.tagName.toLowerCase() !== String(vnode.type).toLowerCase())
+    return { useFastPath: false, reason: "root-tag-mismatch" };
+  const children = vnode.children || vnode.props?.children;
+  if (!Array.isArray(children))
+    return { useFastPath: false, reason: "no-children-array" };
+  for (const c of children) {
+    if (typeof c === "object" && c !== null && "type" in c && typeof c.type === "function") {
+      return { useFastPath: false, reason: "component-child-present" };
+    }
+  }
+  if (instance.mountOperations.length > 0)
+    return { useFastPath: false, reason: "pending-mounts" };
+  try {
+    populateKeyMapForElement(firstChild);
+  } catch {
+  }
+  const oldKeyMap = getKeyMapForElement(firstChild);
+  const decision = isKeyedReorderFastPathEligible(
+    firstChild,
+    children,
+    oldKeyMap
+  );
+  if (!decision.useFastPath || decision.totalKeyed < 128)
+    return { ...decision, useFastPath: false, reason: "renderer-declined" };
+  return { ...decision, useFastPath: true };
+}
+function commitReorderOnly(instance, result) {
+  const evaluate = globalThis.__ASKR_RENDERER?.evaluate;
+  if (typeof evaluate !== "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(() => {
+      evaluate(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/runtime/component.ts
+var currentInstance = null;
+var stateIndex = 0;
+function getCurrentComponentInstance() {
+  return currentInstance;
+}
+function getCurrentInstance() {
+  return currentInstance;
+}
+function getNextStateIndex() {
+  return stateIndex++;
+}
+
+// src/runtime/ssr-bridge.ts
+var defaultBridge = {
+  getCurrentSSRContext() {
+    return null;
+  },
+  throwSSRDataMissing() {
+    throw new Error(
+      "[Askr] SSR data missing (SSR bridge not installed). If you are rendering on the server, ensure you are using the askr SSR entrypoints."
+    );
+  },
+  getCurrentRenderData() {
+    return null;
+  },
+  getNextKey() {
+    throw new Error(
+      "[Askr] getNextKey() called outside SSR render phase (SSR bridge not installed)."
+    );
+  }
+};
+var bridge = defaultBridge;
+function getSSRBridge() {
+  return bridge;
+}
+
+// src/runtime/resource-cell.ts
+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) {
+      getSSRBridge().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/runtime/state.ts
+function state(initialValue) {
+  const instance = getCurrentInstance();
+  if (!instance) {
+    throw new Error(
+      "state() can only be called during component render execution. Move state() calls to the top level of your component function."
+    );
+  }
+  const index = getNextStateIndex();
+  const stateValues = instance.stateValues;
+  if (index < instance.stateIndexCheck) {
+    throw new Error(
+      `State index violation: state() call at index ${index}, but previously saw index ${instance.stateIndexCheck}. This happens when state() is called conditionally (inside if/for/etc). Move all state() calls to the top level of your component function, before any conditionals.`
+    );
+  }
+  invariant(
+    index >= instance.stateIndexCheck,
+    "[State] State indices must increase monotonically"
+  );
+  instance.stateIndexCheck = index;
+  if (instance.firstRenderComplete) {
+    if (!instance.expectedStateIndices.includes(index)) {
+      throw new Error(
+        `Hook order violation: state() called at index ${index}, but this index was not in the first render's sequence [${instance.expectedStateIndices.join(", ")}]. This usually means state() is inside a conditional or loop. Move all state() calls to the top level of your component function.`
+      );
+    }
+  } else {
+    instance.expectedStateIndices.push(index);
+  }
+  if (stateValues[index]) {
+    const existing = stateValues[index];
+    if (existing._owner !== instance) {
+      throw new Error(
+        `State ownership violation: state() called at index ${index} is owned by a different component instance. State ownership is positional and immutable.`
+      );
+    }
+    return existing;
+  }
+  const cell = createStateCell(initialValue, instance);
+  stateValues[index] = cell;
+  return cell;
+}
+function createStateCell(initialValue, instance) {
+  let value = initialValue;
+  const readers = /* @__PURE__ */ new Map();
+  function read() {
+    read._hasBeenRead = true;
+    const inst = getCurrentInstance();
+    if (inst && inst._currentRenderToken !== void 0) {
+      if (!inst._pendingReadStates) inst._pendingReadStates = /* @__PURE__ */ new Set();
+      inst._pendingReadStates.add(read);
+    }
+    return value;
+  }
+  read._readers = readers;
+  read._owner = instance;
+  read.set = (newValueOrUpdater) => {
+    const currentInst = getCurrentInstance();
+    if (currentInst !== null) {
+      throw new Error(
+        `[Askr] state.set() cannot be called during component render. State mutations during render break the actor model and cause infinite loops. Move state updates to event handlers or use conditional rendering instead.`
+      );
+    }
+    let newValue;
+    if (typeof newValueOrUpdater === "function") {
+      const updater = newValueOrUpdater;
+      newValue = updater(value);
+    } else {
+      newValue = newValueOrUpdater;
+    }
+    if (Object.is(value, newValue)) return;
+    if (isBulkCommitActive2()) {
+      value = newValue;
+      return;
+    }
+    value = newValue;
+    const readersMap = read._readers;
+    if (readersMap) {
+      for (const [subInst, token] of readersMap) {
+        if (subInst.lastRenderToken !== token) continue;
+        if (!subInst.hasPendingUpdate) {
+          subInst.hasPendingUpdate = true;
+          const subTask = subInst._pendingFlushTask;
+          if (subTask) globalScheduler.enqueue(subTask);
+          else
+            globalScheduler.enqueue(() => {
+              subInst.hasPendingUpdate = false;
+              subInst.notifyUpdate?.();
+            });
+        }
+      }
+    }
+    const readersMapForOwner = readersMap;
+    const ownerRecordedToken = readersMapForOwner?.get(instance);
+    const ownerShouldEnqueue = (
+      // Normal case: owner read this state in last committed render
+      ownerRecordedToken !== void 0 && instance.lastRenderToken === ownerRecordedToken
+    );
+    if (ownerShouldEnqueue && !instance.hasPendingUpdate) {
+      instance.hasPendingUpdate = true;
+      const task = instance._pendingFlushTask;
+      if (task) globalScheduler.enqueue(task);
+      else
+        globalScheduler.enqueue(() => {
+          instance.hasPendingUpdate = false;
+          instance.notifyUpdate?.();
+        });
+    }
+  };
+  return read;
+}
+
+// src/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);
+  }
+};
+
+// src/runtime/operations.ts
+function resource(fn, deps = []) {
+  const instance = getCurrentComponentInstance();
+  const inst = instance;
+  if (!instance) {
+    const ssr2 = getSSRBridge();
+    const renderData2 = ssr2.getCurrentRenderData();
+    if (renderData2) {
+      const key = ssr2.getNextKey();
+      if (!(key in renderData2)) {
+        ssr2.throwSSRDataMissing();
+      }
+      const val = renderData2[key];
+      return {
+        value: val,
+        pending: false,
+        error: null,
+        refresh: () => {
+        }
+      };
+    }
+    const ssrCtx = ssr2.getCurrentSSRContext();
+    if (ssrCtx) {
+      ssr2.throwSSRDataMissing();
+    }
+    throw new Error(
+      "[Askr] resource() must be called during component render inside an app. Do not create resources at module scope or outside render."
+    );
+  }
+  const ssr = getSSRBridge();
+  const renderData = ssr.getCurrentRenderData();
+  if (renderData) {
+    const key = ssr.getNextKey();
+    if (!(key in renderData)) {
+      ssr.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();
+    });
+    if (inst.ssr) {
+      cell2.start(true, false);
+      if (!cell2.pending) {
+        const cur = holder();
+        cur.snapshot.value = cell2.value;
+        cur.snapshot.pending = cell2.pending;
+        cur.snapshot.error = cell2.error;
+      }
+    } else {
+      globalScheduler.enqueue(() => {
+        try {
+          cell2.start(false, false);
+        } catch (err) {
+          const cur = holder();
+          cur.snapshot.value = cell2.value;
+          cur.snapshot.pending = cell2.pending;
+          cur.snapshot.error = err ?? null;
+          holder.set(cur);
+          inst._enqueueRun?.();
+          return;
+        }
+        if (!cell2.pending) {
+          const cur = holder();
+          cur.snapshot.value = cell2.value;
+          cur.snapshot.pending = cell2.pending;
+          cur.snapshot.error = cell2.error;
+          holder.set(cur);
+          inst._enqueueRun?.();
+        }
+      });
+    }
+  }
+  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 {
+      if (inst.ssr) {
+        cell.start(true, false);
+        if (!cell.pending) {
+          const cur = holder();
+          cur.snapshot.value = cell.value;
+          cur.snapshot.pending = cell.pending;
+          cur.snapshot.error = cell.error;
+        }
+      } else {
+        globalScheduler.enqueue(() => {
+          cell.start(false, false);
+          if (!cell.pending) {
+            const cur = holder();
+            cur.snapshot.value = cell.value;
+            cur.snapshot.pending = cell.pending;
+            cur.snapshot.error = cell.error;
+            holder.set(cur);
+            inst._enqueueRun?.();
+          }
+        });
+      }
+    } 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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resource
+});
+//# sourceMappingURL=index.cjs.map