@askrjs/askr 0.0.2 → 0.0.4

package/dist/fx/index.cjs

@@ -0,0 +1,1193 @@
+"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/fx/index.ts
+var fx_exports = {};
+__export(fx_exports, {
+  debounce: () => debounce,
+  debounceEvent: () => debounceEvent,
+  defer: () => defer,
+  idle: () => idle,
+  once: () => once,
+  raf: () => raf,
+  rafEvent: () => rafEvent,
+  retry: () => retry,
+  scheduleIdle: () => scheduleIdle,
+  scheduleRetry: () => scheduleRetry,
+  scheduleTimeout: () => scheduleTimeout,
+  throttle: () => throttle,
+  throttleEvent: () => throttleEvent,
+  timeout: () => timeout
+});
+module.exports = __toCommonJS(fx_exports);
+
+// src/fx/timing.ts
+function debounce(fn, ms, options) {
+  let timeoutId = null;
+  const { leading = false, trailing = true } = options || {};
+  let lastArgs = null;
+  let lastThis = null;
+  let lastCallTime = 0;
+  const debounced = function(...args) {
+    const callTime = Date.now();
+    lastArgs = args;
+    lastThis = this;
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+    }
+    if (leading && callTime - lastCallTime >= ms) {
+      fn.apply(this, args);
+      lastCallTime = callTime;
+    }
+    if (trailing) {
+      timeoutId = setTimeout(() => {
+        fn.apply(lastThis, lastArgs);
+        timeoutId = null;
+        lastCallTime = Date.now();
+      }, ms);
+    }
+  };
+  debounced.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  return debounced;
+}
+function throttle(fn, ms, options) {
+  let lastCallTime = 0;
+  let timeoutId = null;
+  const { leading = true, trailing = true } = options || {};
+  let lastArgs = null;
+  let lastThis = null;
+  const throttled = function(...args) {
+    const callTime = Date.now();
+    lastArgs = args;
+    lastThis = this;
+    if (leading && callTime - lastCallTime >= ms) {
+      fn.apply(this, args);
+      lastCallTime = callTime;
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    } else if (!leading && lastCallTime === 0) {
+      lastCallTime = callTime;
+    }
+    if (trailing && timeoutId === null) {
+      timeoutId = setTimeout(
+        () => {
+          fn.apply(lastThis, lastArgs);
+          lastCallTime = Date.now();
+          timeoutId = null;
+        },
+        ms - (callTime - lastCallTime)
+      );
+    }
+  };
+  throttled.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  return throttled;
+}
+function once(fn) {
+  let called = false;
+  let result;
+  return ((...args) => {
+    if (!called) {
+      called = true;
+      result = fn(...args);
+    }
+    return result;
+  });
+}
+function defer(fn) {
+  Promise.resolve().then(fn);
+}
+function raf(fn) {
+  let frameId = null;
+  let lastArgs = null;
+  let lastThis = null;
+  return function(...args) {
+    lastArgs = args;
+    lastThis = this;
+    if (frameId === null) {
+      frameId = requestAnimationFrame(() => {
+        fn.apply(lastThis, lastArgs);
+        frameId = null;
+      });
+    }
+  };
+}
+function idle(fn, options) {
+  if (typeof requestIdleCallback !== "undefined") {
+    requestIdleCallback(fn, options ? { timeout: options.timeout } : void 0);
+  } else {
+    Promise.resolve().then(() => {
+      setTimeout(fn, 0);
+    });
+  }
+}
+function timeout(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retry(fn, options) {
+  const {
+    maxAttempts = 3,
+    delayMs = 100,
+    backoff = (i) => delayMs * Math.pow(2, i)
+  } = options || {};
+  let lastError = null;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt < maxAttempts - 1) {
+        const delay = backoff(attempt);
+        await timeout(delay);
+      }
+    }
+  }
+  throw lastError || new Error("Retry failed");
+}
+
+// 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/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;
+function getCurrentComponentInstance() {
+  return currentInstance;
+}
+
+// src/fx/noop.ts
+var noopEventListener = Object.assign((_ev) => {
+}, { cancel() {
+} });
+var noopEventListenerWithFlush = Object.assign((_ev) => {
+}, { cancel() {
+}, flush() {
+} });
+
+// src/fx/fx.ts
+function throwIfDuringRender() {
+  const inst = getCurrentComponentInstance();
+  if (inst !== null) {
+    throw new Error(
+      "[Askr] calling FX handler during render is not allowed. Move calls to event handlers or effects."
+    );
+  }
+}
+function enqueueUserCallback(fn) {
+  globalScheduler.enqueue(() => {
+    try {
+      fn();
+    } catch (err) {
+      logger.error("[Askr] FX handler error:", err);
+    }
+  });
+}
+function debounceEvent(ms, handler, options) {
+  const { leading = false, trailing = true } = options || {};
+  const inst = getCurrentComponentInstance();
+  if (inst && inst.ssr) {
+    return noopEventListenerWithFlush;
+  }
+  let timeoutId = null;
+  let lastEvent = null;
+  let lastCallTime = 0;
+  const debounced = function(ev) {
+    throwIfDuringRender();
+    const now = Date.now();
+    lastEvent = ev;
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    if (leading && now - lastCallTime >= ms) {
+      enqueueUserCallback(() => handler.call(null, ev));
+      lastCallTime = now;
+    }
+    if (trailing) {
+      timeoutId = setTimeout(() => {
+        if (lastEvent) {
+          enqueueUserCallback(() => handler.call(null, lastEvent));
+        }
+        timeoutId = null;
+        lastCallTime = Date.now();
+      }, ms);
+    }
+  };
+  debounced.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    lastEvent = null;
+  };
+  debounced.flush = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      const ev = lastEvent;
+      lastEvent = null;
+      timeoutId = null;
+      if (ev) enqueueUserCallback(() => handler.call(null, ev));
+    }
+  };
+  if (inst) {
+    inst.cleanupFns.push(() => {
+      debounced.cancel();
+    });
+  }
+  return debounced;
+}
+function throttleEvent(ms, handler, options) {
+  const { leading = true, trailing = true } = options || {};
+  const inst = getCurrentComponentInstance();
+  if (inst && inst.ssr) {
+    return noopEventListener;
+  }
+  let lastCallTime = 0;
+  let timeoutId = null;
+  let lastEvent = null;
+  const throttled = function(ev) {
+    throwIfDuringRender();
+    const now = Date.now();
+    lastEvent = ev;
+    if (leading && now - lastCallTime >= ms) {
+      enqueueUserCallback(() => handler.call(null, ev));
+      lastCallTime = now;
+      if (timeoutId !== null) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    } else if (!leading && lastCallTime === 0) {
+      lastCallTime = now;
+    }
+    if (trailing && timeoutId === null) {
+      const wait = ms - (now - lastCallTime);
+      timeoutId = setTimeout(
+        () => {
+          if (lastEvent)
+            enqueueUserCallback(() => handler.call(null, lastEvent));
+          lastCallTime = Date.now();
+          timeoutId = null;
+        },
+        Math.max(0, wait)
+      );
+    }
+  };
+  throttled.cancel = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+    lastEvent = null;
+  };
+  if (inst) {
+    inst.cleanupFns.push(() => throttled.cancel());
+  }
+  return throttled;
+}
+function rafEvent(handler) {
+  const inst = getCurrentComponentInstance();
+  if (inst && inst.ssr) {
+    return noopEventListener;
+  }
+  let frameId = null;
+  let lastEvent = null;
+  const scheduleFrame = () => {
+    const rAF = typeof requestAnimationFrame !== "undefined" ? requestAnimationFrame : (cb) => setTimeout(() => cb(Date.now()), 16);
+    frameId = rAF(() => {
+      frameId = null;
+      if (lastEvent) {
+        const ev = lastEvent;
+        lastEvent = null;
+        enqueueUserCallback(() => handler.call(null, ev));
+      }
+    });
+  };
+  const fn = function(ev) {
+    throwIfDuringRender();
+    lastEvent = ev;
+    if (frameId === null) scheduleFrame();
+  };
+  fn.cancel = () => {
+    if (frameId !== null) {
+      if (typeof cancelAnimationFrame !== "undefined" && typeof frameId === "number") {
+        cancelAnimationFrame(frameId);
+      } else {
+        clearTimeout(frameId);
+      }
+      frameId = null;
+    }
+    lastEvent = null;
+  };
+  if (inst) inst.cleanupFns.push(() => fn.cancel());
+  return fn;
+}
+function scheduleTimeout(ms, fn) {
+  throwIfDuringRender();
+  const inst = getCurrentComponentInstance();
+  if (inst && inst.ssr) {
+    return () => {
+    };
+  }
+  let id = setTimeout(() => {
+    id = null;
+    enqueueUserCallback(fn);
+  }, ms);
+  const cancel = () => {
+    if (id !== null) {
+      clearTimeout(id);
+      id = null;
+    }
+  };
+  if (inst) inst.cleanupFns.push(cancel);
+  return cancel;
+}
+function scheduleIdle(fn, options) {
+  throwIfDuringRender();
+  const inst = getCurrentComponentInstance();
+  if (inst && inst.ssr) return () => {
+  };
+  let id = null;
+  let usingRIC = false;
+  if (typeof requestIdleCallback !== "undefined") {
+    usingRIC = true;
+    id = requestIdleCallback(() => {
+      id = null;
+      enqueueUserCallback(fn);
+    }, options);
+  } else {
+    id = setTimeout(() => {
+      id = null;
+      enqueueUserCallback(fn);
+    }, 0);
+  }
+  const cancel = () => {
+    if (id !== null) {
+      if (usingRIC && typeof cancelIdleCallback !== "undefined" && typeof id === "number") {
+        cancelIdleCallback(id);
+      } else {
+        clearTimeout(id);
+      }
+      id = null;
+    }
+  };
+  if (inst) inst.cleanupFns.push(cancel);
+  return cancel;
+}
+function scheduleRetry(fn, options) {
+  throwIfDuringRender();
+  const inst = getCurrentComponentInstance();
+  if (inst && inst.ssr) return { cancel: () => {
+  } };
+  const {
+    maxAttempts = 3,
+    delayMs = 100,
+    backoff = (i) => delayMs * Math.pow(2, i)
+  } = options || {};
+  let cancelled = false;
+  const attempt = (index) => {
+    if (cancelled) return;
+    globalScheduler.enqueue(() => {
+      if (cancelled) return;
+      const p = fn();
+      p.then(
+        () => {
+        },
+        () => {
+          if (cancelled) return;
+          if (index + 1 < maxAttempts) {
+            const delay = backoff(index);
+            setTimeout(() => {
+              attempt(index + 1);
+            }, delay);
+          }
+        }
+      ).catch((e) => {
+        logger.error("[Askr] scheduleRetry error:", e);
+      });
+    });
+  };
+  attempt(0);
+  const cancel = () => {
+    cancelled = true;
+  };
+  if (inst) inst.cleanupFns.push(cancel);
+  return { cancel };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  debounce,
+  debounceEvent,
+  defer,
+  idle,
+  once,
+  raf,
+  rafEvent,
+  retry,
+  scheduleIdle,
+  scheduleRetry,
+  scheduleTimeout,
+  throttle,
+  throttleEvent,
+  timeout
+});
+//# sourceMappingURL=index.cjs.map