@askrjs/askr 0.0.6 → 0.0.8

package/dist/foundations/index.js

@@ -1,6 +1,194 @@
-// src/foundations/layout.tsx
+// src/foundations/structures/layout.tsx
 function layout(Layout) {
-  return (children, props) => Layout({ ...props, children });
+  return (children, props) => {
+    const mergedProps = { ...props, children };
+    return Layout(mergedProps);
+  };
+}
+
+// src/common/jsx.ts
+var ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("askr.element");
+var Fragment = /* @__PURE__ */ Symbol.for("askr.fragment");
+
+// 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 }
+  };
+}
+
+// src/foundations/structures/slot.tsx
+function Slot(props) {
+  if (props.asChild) {
+    const { children, asChild: _asChild, ...rest } = props;
+    if (isElement(children)) {
+      return cloneElement(children, rest);
+    }
+    return null;
+  }
+  const element = {
+    $$typeof: ELEMENT_TYPE,
+    type: Fragment,
+    props: { children: props.children },
+    key: null
+  };
+  return element;
+}
+
+// src/foundations/structures/presence.ts
+function Presence({
+  present,
+  children
+}) {
+  const isPresent = typeof present === "function" ? present() : Boolean(present);
+  if (!isPresent) return null;
+  const element = {
+    $$typeof: ELEMENT_TYPE,
+    type: Fragment,
+    props: { children },
+    key: null
+  };
+  return element;
+}
+
+// src/foundations/structures/portal.tsx
+function definePortal() {
+  if (typeof createPortalSlot === "function") {
+    let PortalHost2 = function() {
+      return slot.read();
+    };
+    const slot = createPortalSlot();
+    PortalHost2.render = function PortalRender(props) {
+      slot.write(props.children);
+      return null;
+    };
+    return PortalHost2;
+  }
+  let mounted = false;
+  let value;
+  function PortalHostFallback() {
+    mounted = true;
+    return value;
+  }
+  PortalHostFallback.render = function PortalRenderFallback(props) {
+    if (!mounted) return null;
+    value = props.children;
+    return null;
+  };
+  return PortalHostFallback;
+}
+var _defaultPortal;
+function ensureDefaultPortal() {
+  if (!_defaultPortal) _defaultPortal = definePortal();
+  return _defaultPortal;
+}
+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/foundations/utilities/composeHandlers.ts
+function isDefaultPrevented(value) {
+  return typeof value === "object" && value !== null && "defaultPrevented" in value && value.defaultPrevented === true;
+}
+function composeHandlers(first, second, options) {
+  if (!first && !second) {
+    return noop;
+  }
+  if (!first) return second;
+  if (!second) return first;
+  const checkDefaultPrevented = options?.checkDefaultPrevented !== false;
+  return function composed(...args) {
+    first(...args);
+    if (checkDefaultPrevented && isDefaultPrevented(args[0])) {
+      return;
+    }
+    second(...args);
+  };
+}
+function noop() {
+}
+
+// src/foundations/utilities/mergeProps.ts
+function isEventHandlerKey(key) {
+  return key.startsWith("on");
+}
+function mergeProps(base, injected) {
+  const baseKeys = Object.keys(base);
+  if (baseKeys.length === 0) {
+    return injected;
+  }
+  const out = { ...injected };
+  for (const key of baseKeys) {
+    const baseValue = base[key];
+    const injectedValue = injected[key];
+    if (isEventHandlerKey(key) && typeof baseValue === "function" && typeof injectedValue === "function") {
+      out[key] = composeHandlers(
+        injectedValue,
+        baseValue
+      );
+      continue;
+    }
+    out[key] = baseValue;
+  }
+  return out;
+}
+
+// src/foundations/utilities/aria.ts
+function ariaDisabled(disabled) {
+  return disabled ? { "aria-disabled": "true" } : {};
+}
+function ariaExpanded(expanded) {
+  return expanded === void 0 ? {} : { "aria-expanded": String(expanded) };
+}
+function ariaSelected(selected) {
+  return selected === void 0 ? {} : { "aria-selected": String(selected) };
+}
+
+// src/foundations/utilities/composeRef.ts
+function setRef(ref, value) {
+  if (!ref) return;
+  if (typeof ref === "function") {
+    ref(value);
+    return;
+  }
+  try {
+    ref.current = value;
+  } catch {
+  }
+}
+function composeRefs(...refs) {
+  return (value) => {
+    for (const ref of refs) setRef(ref, value);
+  };
+}
+
+// src/foundations/utilities/useId.ts
+function useId(options) {
+  const prefix = options.prefix ?? "askr";
+  return `${prefix}-${String(options.id)}`;
+}
+
+// src/dev/invariant.ts
+function invariant(condition, message, context) {
+  if (!condition) {
+    const contextStr = "";
+    throw new Error(`[Askr Invariant] ${message}${contextStr}`);
+  }
+}
+function assertSchedulingPrecondition(condition, violationMessage) {
+  invariant(condition, `[Scheduler Precondition] ${violationMessage}`);
 }
 
 // src/dev/logger.ts
@@ -33,114 +221,853 @@ var logger = {
   }
 };
 
-// src/common/jsx.ts
-var ELEMENT_TYPE = /* @__PURE__ */ Symbol.for("askr.element");
-var Fragment = /* @__PURE__ */ Symbol.for("askr.fragment");
+// 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) {
+    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) {
+      }
+      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) {
+        }
+      });
+      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/jsx/utils.ts
-function isElement(value) {
-  return typeof value === "object" && value !== null && value.$$typeof === ELEMENT_TYPE;
+// 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 cloneElement(element, props) {
-  return {
-    ...element,
-    props: { ...element.props, ...props }
-  };
+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/foundations/slot.tsx
-function Slot(props) {
-  if (props.asChild) {
-    const { children, ...rest } = props;
-    if (isElement(children)) {
-      return cloneElement(children, rest);
+// 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++;
     }
-    logger.warn("<Slot asChild> expects a single JSX element child.");
-    return null;
   }
+  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 {
-    $$typeof: ELEMENT_TYPE,
-    type: Fragment,
-    props: { children: props.children }
+    useFastPath,
+    totalKeyed,
+    moveCount,
+    lisLen,
+    hasPropChanges
   };
 }
 
-// src/runtime/component.ts
-var currentInstance = null;
-function getCurrentComponentInstance() {
-  return currentInstance;
+// 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/foundations/portal.tsx
-function definePortal() {
-  if (typeof createPortalSlot !== "function") {
-    let HostFallback2 = function() {
-      const inst = getCurrentComponentInstance();
-      if (process.env.NODE_ENV !== "production") {
-        const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
-        ns.__PORTAL_READS = (ns.__PORTAL_READS || 0) + 1;
+// 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) {
+  }
+}
+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;
+          }
+        }
       }
-      if (process.env.NODE_ENV !== "production") ;
-      return inst && owner && inst === owner ? pending : void 0;
-    };
-    let owner = null;
-    let pending;
-    HostFallback2.render = function RenderFallback(props) {
-      return null;
-    };
-    return HostFallback2;
+    }
   }
-  const slot = createPortalSlot();
-  function PortalHost() {
-    return slot.read();
+  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;
   }
-  PortalHost.render = function PortalRender(props) {
+  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") {
-      const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
-      ns.__PORTAL_WRITES = (ns.__PORTAL_WRITES || 0) + 1;
+      validateFastLaneInvariants(instance, schedBefore);
     }
-    slot.write(props.children);
-    return null;
+    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
   };
-  return PortalHost;
+  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`
+      );
+    }
+  }
 }
-var _defaultPortal;
-var _defaultPortalIsFallback = false;
-function ensureDefaultPortal() {
-  if (!_defaultPortal) {
-    if (typeof createPortalSlot === "function") {
-      _defaultPortal = definePortal();
-      _defaultPortalIsFallback = false;
+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/state.ts
+function state(initialValue) {
+  {
+    throw new Error(
+      "state() can only be called during component render execution. Move state() calls to the top level of your component function."
+    );
+  }
+}
+
+// src/foundations/state/controllable.ts
+function isControlled(value) {
+  return value !== void 0;
+}
+function resolveControllable(value, defaultValue) {
+  const controlled = isControlled(value);
+  return {
+    value: controlled ? value : defaultValue,
+    isControlled: controlled
+  };
+}
+function makeControllable(options) {
+  const { value, defaultValue, onChange, setInternal } = options;
+  const { isControlled: isControlled2 } = resolveControllable(value, defaultValue);
+  function set(next) {
+    if (isControlled2) {
+      onChange?.(next);
     } else {
-      _defaultPortal = definePortal();
-      _defaultPortalIsFallback = true;
+      setInternal?.(next);
+      onChange?.(next);
     }
-    return _defaultPortal;
-  }
-  if (_defaultPortalIsFallback && typeof createPortalSlot === "function") {
-    const real = definePortal();
-    _defaultPortal = real;
-    _defaultPortalIsFallback = false;
   }
-  if (!_defaultPortalIsFallback && typeof createPortalSlot !== "function") {
-    const fallback = definePortal();
-    _defaultPortal = fallback;
-    _defaultPortalIsFallback = true;
+  return { set, isControlled: isControlled2 };
+}
+function controllableState(options) {
+  const internal = state(options.defaultValue);
+  const isControlled2 = options.value !== void 0;
+  function read() {
+    return isControlled2 ? options.value : internal();
   }
-  return _defaultPortal;
+  read.set = (nextOrUpdater) => {
+    const prev = read();
+    const next = typeof nextOrUpdater === "function" ? nextOrUpdater(prev) : nextOrUpdater;
+    if (Object.is(prev, next)) return;
+    if (isControlled2) {
+      options.onChange?.(next);
+      return;
+    }
+    internal.set(nextOrUpdater);
+    options.onChange?.(next);
+  };
+  read.isControlled = isControlled2;
+  return read;
 }
-var DefaultPortal = (() => {
-  function Host() {
-    const v = ensureDefaultPortal()();
-    return v === void 0 ? null : v;
+
+// src/foundations/interactions/pressable.ts
+function pressable({
+  disabled,
+  onPress,
+  isNativeButton = false
+}) {
+  const props = {
+    onClick: (e) => {
+      if (disabled) {
+        e.preventDefault?.();
+        e.stopPropagation?.();
+        return;
+      }
+      onPress?.(e);
+    }
+  };
+  if (isNativeButton) {
+    if (disabled) {
+      props.disabled = true;
+      Object.assign(props, ariaDisabled(disabled));
+    }
+    return props;
   }
-  Host.render = function Render(props) {
-    ensureDefaultPortal().render(props);
-    return null;
+  props.role = "button";
+  props.tabIndex = disabled ? -1 : 0;
+  props.onKeyDown = (e) => {
+    if (disabled) {
+      e.preventDefault?.();
+      e.stopPropagation?.();
+      return;
+    }
+    if (e.key === "Enter") {
+      e.preventDefault?.();
+      onPress?.(e);
+      return;
+    }
+    if (e.key === " ") {
+      e.preventDefault?.();
+    }
   };
-  return Host;
-})();
+  props.onKeyUp = (e) => {
+    if (disabled) {
+      e.preventDefault?.();
+      e.stopPropagation?.();
+      return;
+    }
+    if (e.key === " ") {
+      e.preventDefault?.();
+      onPress?.(e);
+    }
+  };
+  if (disabled) Object.assign(props, ariaDisabled(disabled));
+  return props;
+}
+
+// src/foundations/interactions/dismissable.ts
+function dismissable({ onDismiss, disabled }) {
+  return {
+    // Prop for the component root to handle Escape
+    onKeyDown: disabled ? void 0 : (e) => {
+      if (e.key === "Escape") {
+        e.preventDefault?.();
+        e.stopPropagation?.();
+        onDismiss?.();
+      }
+    },
+    // Factory: runtime should attach this listener at the appropriate scope.
+    outsideListener: disabled ? void 0 : (isInside) => (e) => {
+      if (!isInside(e.target)) {
+        e.preventDefault?.();
+        e.stopPropagation?.();
+        onDismiss?.();
+      }
+    }
+  };
+}
+
+// src/foundations/interactions/focusable.ts
+function focusable({
+  disabled,
+  tabIndex
+}) {
+  return {
+    tabIndex: disabled ? -1 : tabIndex === void 0 ? 0 : tabIndex,
+    ...ariaDisabled(disabled)
+  };
+}
+
+// src/foundations/interactions/hoverable.ts
+function hoverable({
+  disabled,
+  onEnter,
+  onLeave
+}) {
+  return {
+    onPointerEnter: disabled ? void 0 : (e) => {
+      onEnter?.(e);
+    },
+    onPointerLeave: disabled ? void 0 : (e) => {
+      onLeave?.(e);
+    }
+  };
+}
 
-export { DefaultPortal, Slot, definePortal, layout };
+export { DefaultPortal, Presence, Slot, ariaDisabled, ariaExpanded, ariaSelected, composeHandlers, composeRefs, controllableState, definePortal, dismissable, focusable, hoverable, isControlled, layout, makeControllable, mergeProps, pressable, resolveControllable, setRef, useId };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map