@askrjs/askr 0.0.5 → 0.0.6

package/dist/component-BBGWJdqJ.d.ts

@@ -0,0 +1,177 @@
+import { P as Props, J as JSXElement } from './jsx-AzPM8gMS.js';
+
+/**
+ * State primitive for Askr components
+ * Optimized for minimal overhead and fast updates
+ *
+ * INVARIANTS ENFORCED:
+ * - state() only callable during component render (currentInstance exists)
+ * - state() called at top-level only (indices must be monotonically increasing)
+ * - state values persist across re-renders (stored in stateValues array)
+ * - state.set() cannot be called during render (causes infinite loops)
+ * - state.set() always enqueues through scheduler (never direct mutation)
+ * - state.set() callback (notifyUpdate) always available
+ */
+
+/**
+ * State value holder - callable to read, has set method to update
+ * @example
+ * const count = state(0);
+ * count();           // read: 0
+ * count.set(1);      // write: triggers re-render
+ */
+interface State<T> {
+    (): T;
+    set(value: T): void;
+    set(updater: (prev: T) => T): void;
+    _hasBeenRead?: boolean;
+    _readers?: Map<ComponentInstance, number>;
+}
+/**
+ * Creates a local state value for a component
+ * Optimized for:
+ * - O(1) read performance
+ * - Minimal allocation per state
+ * - Fast scheduler integration
+ *
+ * IMPORTANT: state() must be called during component render execution.
+ * It captures the current component instance from context.
+ * Calling outside a component function will throw an error.
+ *
+ * @example
+ * ```ts
+ * // ✅ Correct: called during render
+ * export function Counter() {
+ *   const count = state(0);
+ *   return { type: 'button', children: [count()] };
+ * }
+ *
+ * // ❌ Wrong: called outside component
+ * const count = state(0);
+ * export function BadComponent() {
+ *   return { type: 'div' };
+ * }
+ * ```
+ */
+declare function state<T>(initialValue: T): State<T>;
+
+/**
+ * Common call contracts: Component signatures
+ */
+
+type ComponentContext = {
+    signal: AbortSignal;
+};
+type ComponentVNode = {
+    type: string;
+    props?: Props;
+    children?: (string | ComponentVNode | null | undefined | false)[];
+};
+type ComponentFunction = (props: Props, context?: ComponentContext) => JSXElement | ComponentVNode | string | number | null;
+
+/**
+ * Context system: lexical scope + render-time snapshots
+ *
+ * CORE SEMANTIC (Option A — Snapshot-Based):
+ * ============================================
+ * An async resource observes the context of the render that created it.
+ * Context changes only take effect via re-render, not magically mid-await.
+ *
+ * This ensures:
+ * - Deterministic behavior
+ * - Concurrency safety
+ * - Replayable execution
+ * - Debuggability
+ *
+ * INVARIANTS:
+ * - readContext() only works during component render (has currentContextFrame)
+ * - Each render captures a context snapshot
+ * - Async continuations see the snapshot from render start (frozen)
+ * - Provider (Scope) creates a new frame that shadows parent
+ * - Context updates require re-render to take effect
+ */
+
+type ContextKey = symbol;
+interface ContextFrame {
+    parent: ContextFrame | null;
+    values: Map<ContextKey, unknown> | null;
+}
+
+/**
+ * Component instance lifecycle management
+ * Internal only — users never see this
+ */
+
+interface ComponentInstance {
+    id: string;
+    fn: ComponentFunction;
+    props: Props;
+    target: Element | null;
+    mounted: boolean;
+    abortController: AbortController;
+    ssr?: boolean;
+    cleanupStrict?: boolean;
+    stateValues: State<unknown>[];
+    evaluationGeneration: number;
+    notifyUpdate: (() => void) | null;
+    _pendingFlushTask?: () => void;
+    _pendingRunTask?: () => void;
+    _enqueueRun?: () => void;
+    stateIndexCheck: number;
+    expectedStateIndices: number[];
+    firstRenderComplete: boolean;
+    mountOperations: Array<() => void | (() => void) | Promise<void | (() => void)>>;
+    cleanupFns: Array<() => void>;
+    hasPendingUpdate: boolean;
+    ownerFrame: ContextFrame | null;
+    isRoot?: boolean;
+    _currentRenderToken?: number;
+    lastRenderToken?: number;
+    _pendingReadStates?: Set<State<unknown>>;
+    _lastReadStates?: Set<State<unknown>>;
+    _placeholder?: Comment;
+}
+/**
+ * Get the abort signal for the current component
+ * Used to cancel async operations on unmount/navigation
+ *
+ * The signal is guaranteed to be aborted when:
+ * - Component unmounts
+ * - Navigation occurs (different route)
+ * - Parent is destroyed
+ *
+ * IMPORTANT: getSignal() must be called during component render execution.
+ * It captures the current component instance from context.
+ *
+ * @returns AbortSignal that will be aborted when component unmounts
+ * @throws Error if called outside component execution
+ *
+ * @example
+ * ```ts
+ * // ✅ Correct: called during render, used in async operation
+ * export async function UserPage({ id }: { id: string }) {
+ *   const signal = getSignal();
+ *   const user = await fetch(`/api/users/${id}`, { signal });
+ *   return <div>{user.name}</div>;
+ * }
+ *
+ * // ✅ Correct: passed to event handler
+ * export function Button() {
+ *   const signal = getSignal();
+ *   return {
+ *     type: 'button',
+ *     props: {
+ *       onClick: async () => {
+ *         const data = await fetch(url, { signal });
+ *       }
+ *     }
+ *   };
+ * }
+ *
+ * // ❌ Wrong: called outside component context
+ * const signal = getSignal(); // Error: not in component
+ * ```
+ */
+declare function getSignal(): AbortSignal;
+
+export { type ComponentFunction as C, type State as S, getSignal as g, state as s };

package/dist/foundations/index.d.ts

@@ -0,0 +1,32 @@
+export { L as LayoutComponent, l as layout } from '../layout-D5MqtW_q.js';
+import '../types-uOPfcrdz.js';
+import { J as JSXElement } from '../jsx-AzPM8gMS.js';
+
+type SlotProps = {
+    asChild: true;
+    children: JSXElement;
+    [key: string]: unknown;
+} | {
+    asChild?: false;
+    children?: unknown;
+};
+declare function Slot(props: SlotProps): JSXElement | null;
+
+/**
+ * Portal / Host primitive.
+ *
+ * A portal is a named render slot within the existing tree.
+ * It does NOT create a second tree or touch the DOM directly.
+ */
+interface Portal<T = unknown> {
+    /** Mount point — rendered exactly once */
+    (): unknown;
+    /** Render content into the portal */
+    render(props: {
+        children?: T;
+    }): unknown;
+}
+declare function definePortal<T = unknown>(): Portal<T>;
+declare const DefaultPortal: Portal<unknown>;
+
+export { DefaultPortal, JSXElement, type Portal, Slot, type SlotProps, definePortal };

package/dist/foundations/index.js

@@ -0,0 +1,146 @@
+// src/foundations/layout.tsx
+function layout(Layout) {
+  return (children, props) => Layout({ ...props, children });
+}
+
+// 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/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/slot.tsx
+function Slot(props) {
+  if (props.asChild) {
+    const { children, ...rest } = props;
+    if (isElement(children)) {
+      return cloneElement(children, rest);
+    }
+    logger.warn("<Slot asChild> expects a single JSX element child.");
+    return null;
+  }
+  return {
+    $$typeof: ELEMENT_TYPE,
+    type: Fragment,
+    props: { children: props.children }
+  };
+}
+
+// src/runtime/component.ts
+var currentInstance = null;
+function getCurrentComponentInstance() {
+  return currentInstance;
+}
+
+// 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;
+      }
+      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();
+  }
+  PortalHost.render = function PortalRender(props) {
+    if (process.env.NODE_ENV !== "production") {
+      const ns = globalThis.__ASKR__ || (globalThis.__ASKR__ = {});
+      ns.__PORTAL_WRITES = (ns.__PORTAL_WRITES || 0) + 1;
+    }
+    slot.write(props.children);
+    return null;
+  };
+  return PortalHost;
+}
+var _defaultPortal;
+var _defaultPortalIsFallback = false;
+function ensureDefaultPortal() {
+  if (!_defaultPortal) {
+    if (typeof createPortalSlot === "function") {
+      _defaultPortal = definePortal();
+      _defaultPortalIsFallback = false;
+    } else {
+      _defaultPortal = definePortal();
+      _defaultPortalIsFallback = true;
+    }
+    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 _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;
+})();
+
+export { DefaultPortal, Slot, definePortal, layout };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/foundations/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/foundations/layout.tsx","../../src/dev/logger.ts","../../src/common/jsx.ts","../../src/jsx/utils.ts","../../src/foundations/slot.tsx","../../src/runtime/component.ts","../../src/foundations/portal.tsx"],"names":["HostFallback"],"mappings":"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","file":"index.js","sourcesContent":["/**\n * Layout helper.\n *\n * A layout is just a normal component that wraps children.\n * Persistence and reuse are handled by the runtime via component identity.\n *\n * This helper exists purely for readability and convention.\n */\n\nexport type LayoutComponent<P = object> = (\n  props: P & { children?: unknown }\n) => unknown;\n\nexport function layout<P = object>(Layout: LayoutComponent<P>) {\n  return (children?: unknown, props?: P) =>\n    Layout({ ...(props as P), children });\n}\n","/**\n * Centralized logger interface\n * - Keeps production builds silent for debug/warn/info messages\n * - Ensures consistent behavior across the codebase\n * - Protects against missing `console` in some environments\n */\n\nfunction callConsole(method: string, args: unknown[]): void {\n  const c = typeof console !== 'undefined' ? (console as unknown) : undefined;\n  if (!c) return;\n  const fn = (c as Record<string, unknown>)[method];\n  if (typeof fn === 'function') {\n    try {\n      (fn as (...a: unknown[]) => unknown).apply(console, args as unknown[]);\n    } catch {\n      // ignore logging errors\n    }\n  }\n}\n\nexport const logger = {\n  debug: (...args: unknown[]) => {\n    if (process.env.NODE_ENV === 'production') return;\n    callConsole('debug', args);\n  },\n\n  info: (...args: unknown[]) => {\n    if (process.env.NODE_ENV === 'production') return;\n    callConsole('info', args);\n  },\n\n  warn: (...args: unknown[]) => {\n    if (process.env.NODE_ENV === 'production') return;\n    callConsole('warn', args);\n  },\n\n  error: (...args: unknown[]) => {\n    callConsole('error', args);\n  },\n};\n","/**\n * Common call contracts: JSX element shape\n */\n\nimport type { Props } from './props';\n\nexport const ELEMENT_TYPE = Symbol.for('askr.element');\nexport const Fragment = Symbol.for('askr.fragment');\n\nexport interface JSXElement {\n  /** Internal element marker (optional for plain vnode objects) */\n  $$typeof?: symbol;\n\n  /** Element type: string, component, Fragment, etc */\n  type: unknown;\n\n  /** Props bag */\n  props: Props;\n\n  /** Optional key (normalized by runtime) */\n  key?: string | number | null;\n}\n","import { ELEMENT_TYPE, JSXElement } from './types';\n\nexport function isElement(value: unknown): value is JSXElement {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as JSXElement).$$typeof === ELEMENT_TYPE\n  );\n}\n\nexport function cloneElement(\n  element: JSXElement,\n  props: Record<string, unknown>\n): JSXElement {\n  return {\n    ...element,\n    props: { ...element.props, ...props },\n  };\n}\n","import { logger } from '../dev/logger';\nimport { Fragment, cloneElement, isElement, ELEMENT_TYPE } from '../jsx';\nimport type { JSXElement } from '../jsx';\n\nexport type SlotProps =\n  | {\n      asChild: true;\n      children: JSXElement;\n      [key: string]: unknown;\n    }\n  | {\n      asChild?: false;\n      children?: unknown;\n    };\n\nexport function Slot(props: SlotProps): JSXElement | null {\n  if (props.asChild) {\n    const { children, ...rest } = props;\n\n    if (isElement(children)) {\n      return cloneElement(children, rest);\n    }\n\n    logger.warn('<Slot asChild> expects a single JSX element child.');\n\n    return null;\n  }\n\n  // Structural no-op: Slot does not introduce DOM\n  // Return a vnode object for the fragment with the internal element marker.\n  return {\n    $$typeof: ELEMENT_TYPE,\n    type: Fragment,\n    props: { children: props.children },\n  } as JSXElement;\n}\n","/**\n * Component instance lifecycle management\n * Internal only — users never see this\n */\n\nimport { type State } from './state';\nimport { globalScheduler } from './scheduler';\nimport type { Props } from '../common/props';\nimport type { ComponentFunction } from '../common/component';\nimport {\n  // withContext is the sole primitive for context restoration\n  withContext,\n  type ContextFrame,\n} from './context';\nimport { logger } from '../dev/logger';\nimport { __ASKR_incCounter, __ASKR_set } from '../renderer/diag';\n\nexport type { ComponentFunction } from '../common/component';\n\nexport interface ComponentInstance {\n  id: string;\n  fn: ComponentFunction;\n  props: Props;\n  target: Element | null;\n  mounted: boolean;\n  abortController: AbortController; // Per-component abort lifecycle\n  ssr?: boolean; // Set to true for SSR temporary instances\n  // Opt-in strict cleanup mode: when true cleanup errors are aggregated and re-thrown\n  cleanupStrict?: boolean;\n  stateValues: State<unknown>[]; // Persistent state storage across renders\n  evaluationGeneration: number; // Prevents stale async evaluation completions\n  notifyUpdate: (() => void) | null; // Callback for state updates (persisted on instance)\n  // Internal: prebound helpers to avoid per-update closures (allocation hot-path)\n  _pendingFlushTask?: () => void; // Clears hasPendingUpdate and triggers notifyUpdate\n  _pendingRunTask?: () => void; // Clears hasPendingUpdate and runs component\n  _enqueueRun?: () => void; // Batches run requests and enqueues _pendingRunTask\n  stateIndexCheck: number; // Track state indices to catch conditional calls\n  expectedStateIndices: number[]; // Expected sequence of state indices (frozen after first render)\n  firstRenderComplete: boolean; // Flag to detect transition from first to subsequent renders\n  mountOperations: Array<\n    () => void | (() => void) | Promise<void | (() => void)>\n  >; // Operations to run when component mounts\n  cleanupFns: Array<() => void>; // Cleanup functions to run on unmount\n  hasPendingUpdate: boolean; // Flag to batch state updates (coalescing)\n  ownerFrame: ContextFrame | null; // Provider chain for this component (set by Scope, never overwritten)\n  isRoot?: boolean;\n\n  // Render-tracking for precise subscriptions (internal)\n  _currentRenderToken?: number; // Token for the in-progress render (set before render)\n  lastRenderToken?: number; // Token of the last *committed* render\n  _pendingReadStates?: Set<State<unknown>>; // States read during the in-progress render\n  _lastReadStates?: Set<State<unknown>>; // States read during the last committed render\n\n  // Placeholder for null-returning components. When a component initially returns\n  // null, we create a comment placeholder so updates can replace it with content.\n  _placeholder?: Comment;\n}\n\nexport function createComponentInstance(\n  id: string,\n  fn: ComponentFunction,\n  props: Props,\n  target: Element | null\n): ComponentInstance {\n  const instance: ComponentInstance = {\n    id,\n    fn,\n    props,\n    target,\n    mounted: false,\n    abortController: new AbortController(), // Create per-component\n    stateValues: [],\n    evaluationGeneration: 0,\n    notifyUpdate: null,\n    // Prebound helpers (initialized below) to avoid per-update allocations\n    _pendingFlushTask: undefined,\n    _pendingRunTask: undefined,\n    _enqueueRun: undefined,\n    stateIndexCheck: -1,\n    expectedStateIndices: [],\n    firstRenderComplete: false,\n    mountOperations: [],\n    cleanupFns: [],\n    hasPendingUpdate: false,\n    ownerFrame: null, // Will be set by renderer when vnode is marked\n    ssr: false,\n    cleanupStrict: false,\n    isRoot: false,\n\n    // Render-tracking (for precise state subscriptions)\n    _currentRenderToken: undefined,\n    lastRenderToken: 0,\n    _pendingReadStates: new Set(),\n    _lastReadStates: new Set(),\n  };\n\n  // Initialize prebound helper tasks once per instance to avoid allocations\n  instance._pendingRunTask = () => {\n    // Clear pending flag when the run task executes\n    instance.hasPendingUpdate = false;\n    // Execute component run (will set up notifyUpdate before render)\n    runComponent(instance);\n  };\n\n  instance._enqueueRun = () => {\n    if (!instance.hasPendingUpdate) {\n      instance.hasPendingUpdate = true;\n      // Enqueue single run task (coalesces multiple writes)\n      globalScheduler.enqueue(instance._pendingRunTask!);\n    }\n  };\n\n  instance._pendingFlushTask = () => {\n    // Called by state.set() when we want to flush a pending update\n    instance.hasPendingUpdate = false;\n    // Trigger a run via enqueue helper — this will schedule the component run\n    instance._enqueueRun?.();\n  };\n\n  return instance;\n}\n\nlet currentInstance: ComponentInstance | null = null;\nlet stateIndex = 0;\n\n// Export for state.ts to access\nexport function getCurrentComponentInstance(): ComponentInstance | null {\n  return currentInstance;\n}\n\n// Export for SSR to set temporary instance\nexport function setCurrentComponentInstance(\n  instance: ComponentInstance | null\n): void {\n  currentInstance = instance;\n}\n\n/**\n * Register a mount operation that will run after the component is mounted\n * Used by operations (task, on, timer, etc) to execute after render completes\n */\nimport { isBulkCommitActive } from './fastlane';\nimport { evaluate, cleanupInstancesUnder } from '../renderer';\n\nexport function registerMountOperation(\n  operation: () => void | (() => void) | Promise<void | (() => void)>\n): void {\n  const instance = getCurrentComponentInstance();\n  if (instance) {\n    // If we're in bulk-commit fast lane, registering mount operations is a\n    // violation of the fast-lane preconditions. Throw in dev, otherwise ignore\n    // silently in production (we must avoid scheduling work during bulk commit).\n    if (isBulkCommitActive()) {\n      if (process.env.NODE_ENV !== 'production') {\n        throw new Error(\n          'registerMountOperation called during bulk commit fast-lane'\n        );\n      }\n      return;\n    }\n    instance.mountOperations.push(operation);\n  }\n}\n\n/**\n * Execute all mount operations for a component\n * These run after the component is rendered and mounted to the DOM\n */\nfunction executeMountOperations(instance: ComponentInstance): void {\n  // Only execute mount operations for root app instance. Child component\n  // operations are currently registered but should not be executed (per\n  // contract tests). They remain registered for cleanup purposes.\n  if (!instance.isRoot) return;\n\n  for (const operation of instance.mountOperations) {\n    const result = operation();\n    if (result instanceof Promise) {\n      result.then((cleanup) => {\n        if (typeof cleanup === 'function') {\n          instance.cleanupFns.push(cleanup);\n        }\n      });\n    } else if (typeof result === 'function') {\n      instance.cleanupFns.push(result);\n    }\n  }\n  // Clear the operations array so they don't run again on subsequent renders\n  instance.mountOperations = [];\n}\n\nexport function mountInstanceInline(\n  instance: ComponentInstance,\n  target: Element | null\n): void {\n  instance.target = target;\n  // Record backref on host element so renderer can clean up when the\n  // node is removed. Avoids leaks if the node is detached or replaced.\n  try {\n    if (target instanceof Element)\n      (\n        target as Element & { __ASKR_INSTANCE?: ComponentInstance }\n      ).__ASKR_INSTANCE = instance;\n  } catch (err) {\n    void err;\n  }\n\n  // Ensure notifyUpdate is available for async resource completions that may\n  // try to trigger re-render. This mirrors the setup in executeComponent().\n  // Use prebound enqueue helper to avoid allocating a new closure\n  instance.notifyUpdate = instance._enqueueRun!;\n\n  const wasFirstMount = !instance.mounted;\n  instance.mounted = true;\n  if (wasFirstMount && instance.mountOperations.length > 0) {\n    executeMountOperations(instance);\n  }\n}\n\n/**\n * Run a component synchronously: execute function, handle result\n * This is the internal workhorse that manages async continuations and generation tracking.\n * Must always be called through the scheduler.\n *\n * ACTOR INVARIANT: This function is enqueued as a task, never called directly.\n */\nlet _globalRenderCounter = 0;\n\nfunction runComponent(instance: ComponentInstance): void {\n  // CRITICAL: Ensure notifyUpdate is available for state.set() calls during this render.\n  // This must be set before executeComponentSync() runs, not after.\n  // Use prebound enqueue helper to avoid allocating per-render closures\n  instance.notifyUpdate = instance._enqueueRun!;\n\n  // Assign a token for this in-progress render and start a fresh pending-read set\n  instance._currentRenderToken = ++_globalRenderCounter;\n  instance._pendingReadStates = new Set();\n\n  // Atomic rendering: capture DOM state for rollback on error\n  const domSnapshot = instance.target ? instance.target.innerHTML : '';\n\n  const result = executeComponentSync(instance);\n  if (result instanceof Promise) {\n    // Async components are not supported. Components must be synchronous and\n    // must not return a Promise from their render function.\n    throw new Error(\n      'Async components are not supported. Components must be synchronous.'\n    );\n  } else {\n    // Try runtime fast-lane synchronously; if it activates we do not enqueue\n    // follow-up work and the commit happens atomically in this task.\n    // (Runtime fast-lane has conservative preconditions.)\n    const fastlaneBridge = (\n      globalThis as {\n        __ASKR_FASTLANE?: {\n          tryRuntimeFastLaneSync?: (\n            instance: unknown,\n            result: unknown\n          ) => boolean;\n        };\n      }\n    ).__ASKR_FASTLANE;\n    try {\n      const used = fastlaneBridge?.tryRuntimeFastLaneSync?.(instance, result);\n      if (used) return;\n    } catch (err) {\n      // If invariant check failed in dev, surface the error; otherwise fall back\n      if (process.env.NODE_ENV !== 'production') throw err;\n    }\n\n    // Fallback: enqueue the render/commit normally\n    globalScheduler.enqueue(() => {\n      // Handle placeholder-based updates: when a component initially returned null,\n      // we created a comment placeholder. If it now has content, we need to create\n      // a host element and replace the placeholder.\n      if (!instance.target && instance._placeholder) {\n        // Component previously returned null (has placeholder), check if now has content\n        if (result === null || result === undefined) {\n          // Still null - nothing to do, keep placeholder\n          finalizeReadSubscriptions(instance);\n          return;\n        }\n\n        // Has content now - need to create DOM and replace placeholder\n        const placeholder = instance._placeholder;\n        const parent = placeholder.parentNode;\n        if (!parent) {\n          // Placeholder was removed from DOM - can't render\n          logger.warn(\n            '[Askr] placeholder no longer in DOM, cannot render component'\n          );\n          return;\n        }\n\n        // Create a new host element for the content\n        const host = document.createElement('div');\n\n        // Set up instance for normal updates\n        const oldInstance = currentInstance;\n        currentInstance = instance;\n        try {\n          evaluate(result, host);\n\n          // Replace placeholder with host\n          parent.replaceChild(host, placeholder);\n\n          // Set up instance for future updates\n          instance.target = host;\n          instance._placeholder = undefined;\n          (\n            host as Element & { __ASKR_INSTANCE?: ComponentInstance }\n          ).__ASKR_INSTANCE = instance;\n\n          finalizeReadSubscriptions(instance);\n        } finally {\n          currentInstance = oldInstance;\n        }\n        return;\n      }\n\n      if (instance.target) {\n        // Keep `oldChildren` in the outer scope so rollback handlers can\n        // reference the original node list even if the inner try block\n        // throws. This preserves listeners and instance backrefs on rollback.\n        let oldChildren: Node[] = [];\n        try {\n          const wasFirstMount = !instance.mounted;\n          // Ensure nested component executions during evaluation have access to\n          // the current component instance. This allows nested components to\n          // call `state()`, `resource()`, and other runtime helpers which\n          // rely on `getCurrentComponentInstance()` being available.\n          const oldInstance = currentInstance;\n          currentInstance = instance;\n          // Capture snapshot of current children (by reference) so we can\n          // restore them on render failure without losing event listeners or\n          // instance attachments.\n          oldChildren = Array.from(instance.target.childNodes);\n\n          try {\n            evaluate(result, instance.target);\n          } catch (e) {\n            // If evaluation failed, attempt to cleanup any partially-added nodes\n            // and restore the old children to preserve listeners and instances.\n            try {\n              const newChildren = Array.from(instance.target.childNodes);\n              for (const n of newChildren) {\n                try {\n                  cleanupInstancesUnder(n);\n                } catch (err) {\n                  logger.warn(\n                    '[Askr] error cleaning up failed commit children:',\n                    err\n                  );\n                }\n              }\n            } catch (_err) {\n              void _err;\n            }\n\n            // Restore original children by re-inserting the old node references\n            // this preserves attached listeners and instance backrefs.\n            try {\n              __ASKR_incCounter('__DOM_REPLACE_COUNT');\n              __ASKR_set(\n                '__LAST_DOM_REPLACE_STACK_COMPONENT_RESTORE',\n                new Error().stack\n              );\n            } catch (e) {\n              void e;\n            }\n            instance.target.replaceChildren(...oldChildren);\n            throw e;\n          } finally {\n            currentInstance = oldInstance;\n          }\n\n          // Commit succeeded — finalize recorded state reads so subscriptions reflect\n          // the last *committed* render. This updates per-state reader maps\n          // deterministically and synchronously with the commit.\n          finalizeReadSubscriptions(instance);\n\n          instance.mounted = true;\n          // Execute mount operations after first mount (do NOT run these with\n          // currentInstance set - they may perform state mutations/registrations)\n          if (wasFirstMount && instance.mountOperations.length > 0) {\n            executeMountOperations(instance);\n          }\n        } catch (renderError) {\n          // Atomic rendering: rollback on render error. Attempt non-lossy restore of\n          // original child node references to preserve listeners/instances.\n          try {\n            const currentChildren = Array.from(instance.target.childNodes);\n            for (const n of currentChildren) {\n              try {\n                cleanupInstancesUnder(n);\n              } catch (err) {\n                logger.warn(\n                  '[Askr] error cleaning up partial children during rollback:',\n                  err\n                );\n              }\n            }\n          } catch (_err) {\n            void _err;\n          }\n\n          try {\n            try {\n              __ASKR_incCounter('__DOM_REPLACE_COUNT');\n              __ASKR_set(\n                '__LAST_DOM_REPLACE_STACK_COMPONENT_ROLLBACK',\n                new Error().stack\n              );\n            } catch (e) {\n              void e;\n            }\n            instance.target.replaceChildren(...oldChildren);\n          } catch {\n            // Fallback to innerHTML restore if replaceChildren fails for some reason.\n            instance.target.innerHTML = domSnapshot;\n          }\n\n          throw renderError;\n        }\n      }\n    });\n  }\n}\n\n/**\n * Execute a component's render function synchronously.\n * Returns either a vnode/promise immediately (does NOT render).\n * Rendering happens separately through runComponent.\n */\nexport function renderComponentInline(\n  instance: ComponentInstance\n): unknown | Promise<unknown> {\n  // Ensure inline executions (rendered during parent's evaluate) still\n  // receive a render token and have their state reads finalized so\n  // subscriptions are correctly recorded. If this function is called\n  // as part of a scheduled run, the token will already be set by\n  // runComponent and we should not overwrite it.\n  const hadToken = instance._currentRenderToken !== undefined;\n  const prevToken = instance._currentRenderToken;\n  const prevPendingReads = instance._pendingReadStates;\n  if (!hadToken) {\n    instance._currentRenderToken = ++_globalRenderCounter;\n    instance._pendingReadStates = new Set();\n  }\n\n  try {\n    const result = executeComponentSync(instance);\n    // If we set the token for inline execution, finalize subscriptions now\n    // because the component is effectively committed as part of the parent's\n    // synchronous evaluation.\n    if (!hadToken) {\n      finalizeReadSubscriptions(instance);\n    }\n    return result;\n  } finally {\n    // Restore previous token/read states for nested inline render scenarios\n    instance._currentRenderToken = prevToken;\n    instance._pendingReadStates = prevPendingReads ?? new Set();\n  }\n}\n\nfunction executeComponentSync(\n  instance: ComponentInstance\n): unknown | Promise<unknown> {\n  // Reset state index tracking for this render\n  instance.stateIndexCheck = -1;\n\n  // Reset read tracking for all existing state\n  for (const state of instance.stateValues) {\n    if (state) {\n      state._hasBeenRead = false;\n    }\n  }\n\n  // Prepare pending read set for this render (reads will be finalized on commit)\n  instance._pendingReadStates = new Set();\n\n  currentInstance = instance;\n  stateIndex = 0;\n\n  try {\n    // Track render time in dev mode\n    const renderStartTime =\n      process.env.NODE_ENV !== 'production' ? Date.now() : 0;\n\n    // Create context object with abort signal\n    const context = {\n      signal: instance.abortController.signal,\n    };\n\n    // Execute component within its owner frame (provider chain).\n    // This ensures all context reads see the correct provider values.\n    // We create a new execution frame whose parent is the ownerFrame. The\n    // `values` map is lazily allocated to avoid per-render Map allocations\n    // for components that do not use context.\n    const executionFrame: ContextFrame = {\n      parent: instance.ownerFrame,\n      values: null,\n    };\n    const result = withContext(executionFrame, () =>\n      instance.fn(instance.props, context)\n    );\n\n    // Check render time\n    const renderTime = Date.now() - renderStartTime;\n    if (renderTime > 5) {\n      // Warn if render takes more than 5ms\n      logger.warn(\n        `[askr] Slow render detected: ${renderTime}ms. Consider optimizing component performance.`\n      );\n    }\n\n    // Mark first render complete after successful execution\n    // This enables hook order validation on subsequent renders\n    if (!instance.firstRenderComplete) {\n      instance.firstRenderComplete = true;\n    }\n\n    // Check for unused state\n    for (let i = 0; i < instance.stateValues.length; i++) {\n      const state = instance.stateValues[i];\n      if (state && !state._hasBeenRead) {\n        try {\n          const name = instance.fn?.name || '<anonymous>';\n          logger.warn(\n            `[askr] Unused state variable detected in ${name} at index ${i}. State should be read during render or removed.`\n          );\n        } catch {\n          logger.warn(\n            `[askr] Unused state variable detected. State should be read during render or removed.`\n          );\n        }\n      }\n    }\n\n    return result;\n  } finally {\n    // Synchronous path: we did not push a fresh frame, so nothing to pop here.\n    currentInstance = null;\n  }\n}\n\n/**\n * Public entry point: Execute component with full lifecycle (execute + render)\n * Handles both initial mount and re-execution. Always enqueues through scheduler.\n * Single entry point to avoid lifecycle divergence.\n */\nexport function executeComponent(instance: ComponentInstance): void {\n  // Create a fresh abort controller on mount to allow remounting\n  // (old one may have been aborted during previous cleanup)\n  instance.abortController = new AbortController();\n\n  // Setup notifyUpdate callback using prebound helper to avoid per-call closures\n  instance.notifyUpdate = instance._enqueueRun!;\n\n  // Enqueue the initial component run\n  globalScheduler.enqueue(() => runComponent(instance));\n}\n\nexport function getCurrentInstance(): ComponentInstance | null {\n  return currentInstance;\n}\n\n/**\n * Get the abort signal for the current component\n * Used to cancel async operations on unmount/navigation\n *\n * The signal is guaranteed to be aborted when:\n * - Component unmounts\n * - Navigation occurs (different route)\n * - Parent is destroyed\n *\n * IMPORTANT: getSignal() must be called during component render execution.\n * It captures the current component instance from context.\n *\n * @returns AbortSignal that will be aborted when component unmounts\n * @throws Error if called outside component execution\n *\n * @example\n * ```ts\n * // ✅ Correct: called during render, used in async operation\n * export async function UserPage({ id }: { id: string }) {\n *   const signal = getSignal();\n *   const user = await fetch(`/api/users/${id}`, { signal });\n *   return <div>{user.name}</div>;\n * }\n *\n * // ✅ Correct: passed to event handler\n * export function Button() {\n *   const signal = getSignal();\n *   return {\n *     type: 'button',\n *     props: {\n *       onClick: async () => {\n *         const data = await fetch(url, { signal });\n *       }\n *     }\n *   };\n * }\n *\n * // ❌ Wrong: called outside component context\n * const signal = getSignal(); // Error: not in component\n * ```\n */\nexport function getSignal(): AbortSignal {\n  if (!currentInstance) {\n    throw new Error(\n      'getSignal() can only be called during component render execution. ' +\n        'Ensure you are calling this from inside your component function.'\n    );\n  }\n  return currentInstance.abortController.signal;\n}\n\n/**\n * Finalize read subscriptions for an instance after a successful commit.\n * - Update per-state readers map to point to this instance's last committed token\n * - Remove this instance from states it no longer reads\n * This is deterministic and runs synchronously with commit to ensure\n * subscribers are only notified when they actually read a state in their\n * last committed render.\n */\nexport function finalizeReadSubscriptions(instance: ComponentInstance): void {\n  const newSet = instance._pendingReadStates ?? new Set();\n  const oldSet = instance._lastReadStates ?? new Set();\n  const token = instance._currentRenderToken;\n\n  if (token === undefined) return;\n\n  // Remove subscriptions for states that were read previously but not in this render\n  for (const s of oldSet) {\n    if (!newSet.has(s)) {\n      const readers = (s as State<unknown>)._readers;\n      if (readers) readers.delete(instance);\n    }\n  }\n\n  // Commit token becomes the authoritative token for this instance's last render\n  instance.lastRenderToken = token;\n\n  // Record subscriptions for states read during this render\n  for (const s of newSet) {\n    let readers = (s as State<unknown>)._readers;\n    if (!readers) {\n      readers = new Map();\n      // s is a State object; assign its _readers map\n      (s as State<unknown>)._readers = readers;\n    }\n    readers.set(instance, instance.lastRenderToken ?? 0);\n  }\n\n  instance._lastReadStates = newSet;\n  instance._pendingReadStates = new Set();\n  instance._currentRenderToken = undefined;\n}\n\nexport function getNextStateIndex(): number {\n  return stateIndex++;\n}\n\n/**\n * Mount a component instance.\n * This is just an alias to executeComponent() to maintain API compatibility.\n * All lifecycle logic is unified in executeComponent().\n */\nexport function mountComponent(instance: ComponentInstance): void {\n  executeComponent(instance);\n}\n\n/**\n * Clean up component — abort pending operations\n * Called on unmount or route change\n */\nexport function cleanupComponent(instance: ComponentInstance): void {\n  // Execute cleanup functions (from mount effects)\n  const cleanupErrors: unknown[] = [];\n  for (const cleanup of instance.cleanupFns) {\n    try {\n      cleanup();\n    } catch (err) {\n      if (instance.cleanupStrict) {\n        cleanupErrors.push(err);\n      } else {\n        // Preserve previous behavior: log warnings in dev and continue\n        if (process.env.NODE_ENV !== 'production') {\n          logger.warn('[Askr] cleanup function threw:', err);\n        }\n      }\n    }\n  }\n  instance.cleanupFns = [];\n  if (cleanupErrors.length > 0) {\n    // If strict mode, surface all cleanup errors as an AggregateError after attempting all cleanups\n    throw new AggregateError(\n      cleanupErrors,\n      `Cleanup failed for component ${instance.id}`\n    );\n  }\n\n  // Remove deterministic state subscriptions for this instance\n  if (instance._lastReadStates) {\n    for (const s of instance._lastReadStates) {\n      const readers = (s as State<unknown>)._readers;\n      if (readers) readers.delete(instance);\n    }\n    instance._lastReadStates = new Set();\n  }\n\n  // Abort all pending operations\n  instance.abortController.abort();\n\n  // Clear update callback to prevent dangling references and stale updates\n  instance.notifyUpdate = null;\n\n  // Mark instance as unmounted so external tracking (e.g., portal host lists)\n  // can deterministically prune stale instances. Not marking this leads to\n  // retained \"mounted\" flags across cleanup boundaries which breaks\n  // owner selection in the portal fallback.\n  instance.mounted = false;\n}\n","/**\n * Portal / Host primitive.\n *\n * A portal is a named render slot within the existing tree.\n * It does NOT create a second tree or touch the DOM directly.\n */\n\nimport { getCurrentComponentInstance } from '../runtime/component';\nimport type { ComponentInstance } from '../runtime/component';\nimport { logger } from '../dev/logger';\n\nexport interface Portal<T = unknown> {\n  /** Mount point — rendered exactly once */\n  (): unknown;\n\n  /** Render content into the portal */\n  render(props: { children?: T }): unknown;\n}\n\nexport function definePortal<T = unknown>(): Portal<T> {\n  // If the runtime primitive isn't installed yet, provide a no-op fallback.\n  // Using `typeof createPortalSlot` is safe even if the identifier is not\n  // defined at runtime (it returns 'undefined' rather than throwing).\n  if (typeof createPortalSlot !== 'function') {\n    // Fallback implementation for environments where the runtime primitive\n    // isn't available (tests, SSR).\n    //\n    // Invariants this fallback tries to maintain:\n    // - Always use the *current* host instance (update `owner` each render)\n    // - Preserve the last `value` written before host mounts and expose it so\n    //   it can be flushed into a real portal if/when the runtime installs\n    // - Schedule `owner.notifyUpdate()` when a host exists so updates are\n    //   reflected immediately\n    // Fast fallback for module/SSR/test environments.\n    // Track a single owner to avoid per-render array scans.\n    let owner: ComponentInstance | null = null;\n    let pending: T | undefined;\n\n    function HostFallback() {\n      // Drop owner + pending when owner unmounts to avoid replay.\n      if (owner && owner.mounted === false) {\n        owner = null;\n        pending = undefined;\n      }\n\n      const inst = getCurrentComponentInstance();\n\n      // Capture the first host as the owner.\n      // We intentionally do NOT require `mounted === true` here because the\n      // host can render before the runtime flips its mounted flag. Capturing\n      // early ensures `DefaultPortal.render()` works immediately after mount.\n      if (!owner && inst) owner = inst;\n\n      /* istanbul ignore if */\n      if (process.env.NODE_ENV !== 'production') {\n        const ns =\n          (globalThis as unknown as { __ASKR__?: Record<string, unknown> })\n            .__ASKR__ ||\n          ((\n            globalThis as unknown as { __ASKR__?: Record<string, unknown> }\n          ).__ASKR__ = {} as Record<string, unknown>);\n        ns.__PORTAL_READS = ((ns.__PORTAL_READS as number) || 0) + 1;\n      }\n\n      /* istanbul ignore if */\n      if (process.env.NODE_ENV !== 'production') {\n        // Minimal dev diagnostics; avoid heavy allocations in the hot path.\n        if (inst && owner && inst !== owner && inst.mounted === true) {\n          logger.warn(\n            '[Portal] multiple mounted hosts detected; first mounted host is owner'\n          );\n        }\n      }\n\n      return inst && owner && inst === owner ? (pending as unknown) : undefined;\n    }\n\n    HostFallback.render = function RenderFallback(props: { children?: T }) {\n      // Owner must be fully mounted (mounted === true) to accept writes.\n      if (!owner || owner.mounted !== true) return null;\n\n      /* istanbul ignore if */\n      if (process.env.NODE_ENV !== 'production') {\n        const ns =\n          (globalThis as unknown as { __ASKR__?: Record<string, unknown> })\n            .__ASKR__ ||\n          ((\n            globalThis as unknown as { __ASKR__?: Record<string, unknown> }\n          ).__ASKR__ = {} as Record<string, unknown>);\n        ns.__PORTAL_WRITES = ((ns.__PORTAL_WRITES as number) || 0) + 1;\n      }\n\n      // Update pending value for the live owner\n      pending = props.children as T | undefined;\n\n      // Schedule an update on the owner so it re-renders\n      if (owner.notifyUpdate) owner.notifyUpdate();\n      return null;\n    };\n\n    return HostFallback as Portal<T>;\n  }\n\n  // Runtime-provided slot implementation\n  const slot = createPortalSlot<T>();\n\n  function PortalHost() {\n    return slot.read();\n  }\n\n  PortalHost.render = function PortalRender(props: { children?: T }) {\n    // Keep counter increment guarded for dev-only behavior\n    /* istanbul ignore if */\n    if (process.env.NODE_ENV !== 'production') {\n      const ns =\n        (globalThis as unknown as { __ASKR__?: Record<string, unknown> })\n          .__ASKR__ ||\n        ((\n          globalThis as unknown as { __ASKR__?: Record<string, unknown> }\n        ).__ASKR__ = {} as Record<string, unknown>);\n      ns.__PORTAL_WRITES = ((ns.__PORTAL_WRITES as number) || 0) + 1;\n    }\n    slot.write(props.children);\n    return null;\n  };\n\n  return PortalHost as Portal<T>;\n}\n\n// Default portal instance: lazily created wrapper so runtime primitive is not\n// invoked during module initialization (avoids ReferenceError when runtime\n// slot primitive is not yet installed).\nlet _defaultPortal: Portal<unknown> | undefined;\nlet _defaultPortalIsFallback = false;\n\n/**\n * Reset the default portal state. Used by tests to ensure isolation.\n * @internal\n */\nexport function _resetDefaultPortal(): void {\n  _defaultPortal = undefined;\n  _defaultPortalIsFallback = false;\n}\n\nfunction ensureDefaultPortal(): Portal<unknown> {\n  // If a portal hasn't been initialized yet, create a real portal if the\n  // runtime primitive exists; otherwise create a fallback. If a fallback\n  // was previously created and the runtime primitive becomes available\n  // later, replace the fallback with a real portal on first use.\n  if (!_defaultPortal) {\n    if (typeof createPortalSlot === 'function') {\n      _defaultPortal = definePortal<unknown>();\n      _defaultPortalIsFallback = false;\n    } else {\n      // Create a fallback via definePortal so it uses the same owner/pending\n      // semantics as the non-default portals (keeps runtime and fallback\n      // behavior consistent).\n      _defaultPortal = definePortal<unknown>();\n      _defaultPortalIsFallback = true;\n    }\n    return _defaultPortal;\n  }\n\n  // Replace fallback with real portal once runtime primitive becomes available\n  // NOTE: We intentionally do NOT replay pending writes from a fallback.\n  // Early writes are dropped by design to avoid replaying invisible UI.\n  if (_defaultPortalIsFallback && typeof createPortalSlot === 'function') {\n    const real = definePortal<unknown>();\n    _defaultPortal = real;\n    _defaultPortalIsFallback = false;\n  }\n\n  // If the runtime primitive is removed (tests may simulate this by\n  // deleting `createPortalSlot` between runs), revert to a fallback so\n  // subsequent tests observe the appropriate fallback semantics.\n  if (!_defaultPortalIsFallback && typeof createPortalSlot !== 'function') {\n    const fallback = definePortal<unknown>();\n    _defaultPortal = fallback;\n    _defaultPortalIsFallback = true;\n  }\n\n  return _defaultPortal;\n}\n\nexport const DefaultPortal: Portal<unknown> = (() => {\n  function Host() {\n    // Delegate to the lazily-created portal host (created when runtime is ready)\n    // Return null when no pending value exists so the component renders nothing\n    // (consistent with SSR which renders Fragment children as empty string)\n    const v = ensureDefaultPortal()();\n    return v === undefined ? null : v;\n  }\n  Host.render = function Render(props: { children?: unknown }) {\n    ensureDefaultPortal().render(props);\n    return null;\n  };\n  return Host as Portal<unknown>;\n})();\n\n/**\n * NOTE:\n * createPortalSlot is a runtime primitive.\n * It owns scheduling, consistency, and SSR behavior.\n */\ndeclare function createPortalSlot<T>(): {\n  read(): unknown;\n  write(value: T | undefined): void;\n};\n"]}

package/dist/{fx.js → fx/index.js}

@@ -632,5 +632,5 @@ function scheduleRetry(fn, options) {
 }
 
 export { debounce, debounceEvent, defer, idle, once, raf, rafEvent, retry, scheduleIdle, scheduleRetry, scheduleTimeout, throttle, throttleEvent, timeout };
-//# sourceMappingURL=fx.js.map
-//# sourceMappingURL=fx.js.map
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/fx/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/fx/timing.ts","../../src/dev/invariant.ts","../../src/dev/logger.ts","../../src/runtime/scheduler.ts","../../src/fx/noop.ts","../../src/fx/fx.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * Timing utilities — pure helpers for common async patterns\n * No framework coupling. No lifecycle awareness.\n */\n\nexport interface DebounceOptions {\n  leading?: boolean;\n  trailing?: boolean;\n}\n\nexport interface ThrottleOptions {\n  leading?: boolean;\n  trailing?: boolean;\n}\n\nexport interface RetryOptions {\n  maxAttempts?: number;\n  delayMs?: number;\n  backoff?: (attemptIndex: number) => number;\n}\n\n/**\n * Debounce — delay execution, coalesce rapid calls\n *\n * Useful for: text input, resize, autosave\n *\n * @param fn Function to debounce\n * @param ms Delay in milliseconds\n * @param options trailing (default true), leading\n * @returns Debounced function with cancel() method\n *\n * @example\n * ```ts\n * const save = debounce((text) => api.save(text), 500);\n * input.addEventListener('input', (e) => save(e.target.value));\n * save.cancel(); // stop any pending execution\n * ```\n */\nexport function debounce<T extends (...args: unknown[]) => unknown>(\n  fn: T,\n  ms: number,\n  options?: DebounceOptions\n): T & { cancel(): void } {\n  let timeoutId: NodeJS.Timeout | null = null;\n  const { leading = false, trailing = true } = options || {};\n  let lastArgs: unknown[] | null = null;\n  let lastThis: unknown = null;\n  let lastCallTime = 0;\n\n  const debounced = function (this: unknown, ...args: unknown[]) {\n    const callTime = Date.now();\n    lastArgs = args;\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    lastThis = this;\n\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n    }\n\n    if (leading && callTime - lastCallTime >= ms) {\n      fn.apply(this, args);\n      lastCallTime = callTime;\n    }\n\n    if (trailing) {\n      timeoutId = setTimeout(() => {\n        fn.apply(lastThis, lastArgs!);\n        timeoutId = null;\n        lastCallTime = Date.now();\n      }, ms);\n    }\n  };\n\n  debounced.cancel = () => {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n  };\n\n  return debounced as T & { cancel(): void };\n}\n\n/**\n * Throttle — rate-limit execution, keep first/last\n *\n * Useful for: scroll, mouse move, high-frequency events\n *\n * @param fn Function to throttle\n * @param ms Minimum interval between calls in milliseconds\n * @param options leading (default true), trailing (default true)\n * @returns Throttled function with cancel() method\n *\n * @example\n * ```ts\n * const handleScroll = throttle(updateUI, 100);\n * window.addEventListener('scroll', handleScroll);\n * handleScroll.cancel();\n * ```\n */\nexport function throttle<T extends (...args: unknown[]) => unknown>(\n  fn: T,\n  ms: number,\n  options?: ThrottleOptions\n): T & { cancel(): void } {\n  let lastCallTime = 0;\n  let timeoutId: NodeJS.Timeout | null = null;\n  const { leading = true, trailing = true } = options || {};\n  let lastArgs: unknown[] | null = null;\n  let lastThis: unknown = null;\n\n  const throttled = function (this: unknown, ...args: unknown[]) {\n    const callTime = Date.now();\n    lastArgs = args;\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    lastThis = this;\n\n    if (leading && callTime - lastCallTime >= ms) {\n      fn.apply(this, args);\n      lastCallTime = callTime;\n      if (timeoutId !== null) {\n        clearTimeout(timeoutId);\n        timeoutId = null;\n      }\n    } else if (!leading && lastCallTime === 0) {\n      lastCallTime = callTime;\n    }\n\n    if (trailing && timeoutId === null) {\n      timeoutId = setTimeout(\n        () => {\n          fn.apply(lastThis, lastArgs!);\n          lastCallTime = Date.now();\n          timeoutId = null;\n        },\n        ms - (callTime - lastCallTime)\n      );\n    }\n  };\n\n  throttled.cancel = () => {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n  };\n\n  return throttled as T & { cancel(): void };\n}\n\n/**\n * Once — guard against double execution\n *\n * Useful for: init logic, event safety\n *\n * @param fn Function to call at most once\n * @returns Function that executes fn only on first call\n *\n * @example\n * ```ts\n * const init = once(setup);\n * init(); // runs\n * init(); // does nothing\n * init(); // does nothing\n * ```\n */\nexport function once<T extends (...args: unknown[]) => unknown>(fn: T): T {\n  let called = false;\n  let result: unknown;\n\n  return ((...args: unknown[]) => {\n    if (!called) {\n      called = true;\n      result = fn(...args);\n    }\n    return result;\n  }) as T;\n}\n\n/**\n * Defer — schedule on microtask queue\n *\n * Useful for: run-after-current-stack logic\n * More reliable than setTimeout(..., 0)\n *\n * @param fn Function to defer\n *\n * @example\n * ```ts\n * defer(() => update()); // runs after current stack, before next macrotask\n * ```\n */\nexport function defer(fn: () => void): void {\n  Promise.resolve().then(fn);\n}\n\n/**\n * RAF — coalesce multiple updates into single frame\n *\n * Useful for: animation, layout work, render updates\n *\n * @param fn Function to schedule on next animation frame\n * @returns Function that schedules fn on requestAnimationFrame\n *\n * @example\n * ```ts\n * const update = raf(render);\n * update(); // schedules on next frame\n * update(); // same frame, no duplicate\n * ```\n */\nexport function raf<T extends (...args: unknown[]) => unknown>(fn: T): T {\n  let frameId: number | null = null;\n  let lastArgs: unknown[] | null = null;\n  let lastThis: unknown = null;\n\n  return function (this: unknown, ...args: unknown[]) {\n    lastArgs = args;\n    // eslint-disable-next-line @typescript-eslint/no-this-alias\n    lastThis = this;\n\n    if (frameId === null) {\n      frameId = requestAnimationFrame(() => {\n        fn.apply(lastThis, lastArgs!);\n        frameId = null;\n      });\n    }\n  } as T;\n}\n\n/**\n * Idle — schedule low-priority work\n *\n * Useful for: background prep, non-urgent updates\n * Falls back to setTimeout if requestIdleCallback unavailable\n *\n * @param fn Function to call when idle\n * @param options timeout for fallback\n *\n * @example\n * ```ts\n * idle(() => prefetchData());\n * ```\n */\nexport function idle(fn: () => void, options?: { timeout?: number }): void {\n  if (typeof requestIdleCallback !== 'undefined') {\n    requestIdleCallback(fn, options ? { timeout: options.timeout } : undefined);\n  } else {\n    // Fallback: defer to microtask, then use setTimeout\n    Promise.resolve().then(() => {\n      setTimeout(fn, 0);\n    });\n  }\n}\n\n/**\n * Timeout — Promise-based delay\n *\n * Useful for: readable async code, waiting between retries\n *\n * @param ms Milliseconds to wait\n * @returns Promise that resolves after delay\n *\n * @example\n * ```ts\n * await timeout(300);\n * console.log('300ms later');\n * ```\n */\nexport function timeout(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\n/**\n * Retry — attempt function with backoff\n *\n * Useful for: network calls, transient failures\n *\n * @param fn Async function to retry\n * @param options maxAttempts, delayMs, backoff function\n * @returns Promise with final result or error\n *\n * @example\n * ```ts\n * const data = await retry(() => fetch(url), {\n *   maxAttempts: 3,\n *   delayMs: 100,\n * });\n * ```\n */\nexport async function retry<T>(\n  fn: () => Promise<T>,\n  options?: RetryOptions\n): Promise<T> {\n  const {\n    maxAttempts = 3,\n    delayMs = 100,\n    backoff = (i: number) => delayMs * Math.pow(2, i),\n  } = options || {};\n\n  let lastError: Error | null = null;\n\n  for (let attempt = 0; attempt < maxAttempts; attempt++) {\n    try {\n      return await fn();\n    } catch (error) {\n      lastError = error as Error;\n      if (attempt < maxAttempts - 1) {\n        const delay = backoff(attempt);\n        await timeout(delay);\n      }\n    }\n  }\n\n  throw lastError || new Error('Retry failed');\n}\n","/**\n * Invariant assertion utilities for correctness checking\n * Production-safe: invariants are enforced at build-time or with minimal overhead\n *\n * Core principle: fail fast when invariants are violated\n * All functions throw descriptive errors for debugging\n */\n\n/**\n * Assert a condition; throw with context if false\n * @internal\n */\nexport function invariant(\n  condition: boolean,\n  message: string,\n  context?: Record<string, unknown>\n): asserts condition {\n  if (!condition) {\n    const contextStr = context ? '\\n' + JSON.stringify(context, null, 2) : '';\n    throw new Error(`[Askr Invariant] ${message}${contextStr}`);\n  }\n}\n\n/**\n * Assert object property exists and has correct type\n * @internal\n */\nexport function assertProperty<T extends object, K extends keyof T>(\n  obj: T,\n  prop: K,\n  expectedType?: string\n): asserts obj is T & Required<Pick<T, K>> {\n  invariant(prop in obj, `Object missing required property '${String(prop)}'`, {\n    object: obj,\n  });\n\n  if (expectedType) {\n    const actualType = typeof obj[prop];\n    invariant(\n      actualType === expectedType,\n      `Property '${String(prop)}' has type '${actualType}', expected '${expectedType}'`,\n      { value: obj[prop], expectedType }\n    );\n  }\n}\n\n/**\n * Assert a reference is not null/undefined\n * @internal\n */\nexport function assertDefined<T>(\n  value: T | null | undefined,\n  message: string\n): asserts value is T {\n  invariant(value !== null && value !== undefined, message, { value });\n}\n\n/**\n * Assert a task runs exactly once atomically\n * Useful for verifying lifecycle events fire precisely when expected\n * @internal\n */\nexport class Once {\n  private called = false;\n  private calledAt: number | null = null;\n  readonly name: string;\n\n  constructor(name: string) {\n    this.name = name;\n  }\n\n  check(): boolean {\n    return this.called;\n  }\n\n  mark(): void {\n    invariant(\n      !this.called,\n      `${this.name} called multiple times (previously at ${this.calledAt}ms)`,\n      { now: Date.now() }\n    );\n    this.called = true;\n    this.calledAt = Date.now();\n  }\n\n  reset(): void {\n    this.called = false;\n    this.calledAt = null;\n  }\n}\n\n/**\n * Assert a value falls in an enumerated set\n * @internal\n */\nexport function assertEnum<T extends readonly unknown[]>(\n  value: unknown,\n  allowedValues: T,\n  fieldName: string\n): asserts value is T[number] {\n  invariant(\n    allowedValues.includes(value),\n    `${fieldName} must be one of [${allowedValues.join(', ')}], got ${JSON.stringify(value)}`,\n    { value, allowed: allowedValues }\n  );\n}\n\n/**\n * Assert execution context (scheduler, component, etc)\n * @internal\n */\nexport function assertContext(\n  actual: unknown,\n  expected: unknown,\n  contextName: string\n): asserts actual is typeof expected {\n  invariant(\n    actual === expected,\n    `Invalid ${contextName} context. Expected ${expected}, got ${actual}`,\n    { expected, actual }\n  );\n}\n\n/**\n * Assert scheduling precondition (not reentering, not during render, etc)\n * @internal\n */\nexport function assertSchedulingPrecondition(\n  condition: boolean,\n  violationMessage: string\n): asserts condition {\n  invariant(condition, `[Scheduler Precondition] ${violationMessage}`);\n}\n\n/**\n * Assert state precondition\n * @internal\n */\nexport function assertStatePrecondition(\n  condition: boolean,\n  violationMessage: string\n): asserts condition {\n  invariant(condition, `[State Precondition] ${violationMessage}`);\n}\n\n/**\n * Verify AbortController lifecycle\n * @internal\n */\nexport function assertAbortControllerState(\n  signal: AbortSignal,\n  expectedAborted: boolean,\n  context: string\n): void {\n  invariant(\n    signal.aborted === expectedAborted,\n    `AbortSignal ${expectedAborted ? 'should be' : 'should not be'} aborted in ${context}`,\n    { actual: signal.aborted, expected: expectedAborted }\n  );\n}\n\n/**\n * Guard: throw if callback is null when it shouldn't be\n * Used for notifyUpdate, event handlers, etc.\n * @internal\n */\nexport function assertCallbackAvailable<\n  T extends (...args: unknown[]) => unknown,\n>(callback: T | null | undefined, callbackName: string): asserts callback is T {\n  invariant(\n    callback !== null && callback !== undefined,\n    `${callbackName} callback is required but not available`,\n    { callback }\n  );\n}\n\n/**\n * Verify evaluation generation prevents stale evaluations\n * @internal\n */\nexport function assertEvaluationGeneration(\n  current: number,\n  latest: number,\n  context: string\n): void {\n  invariant(\n    current === latest,\n    `Stale evaluation generation in ${context}: current ${current}, latest ${latest}`,\n    { current, latest }\n  );\n}\n\n/**\n * Verify mounted flag state\n * @internal\n */\nexport function assertMountedState(\n  mounted: boolean,\n  expectedMounted: boolean,\n  context: string\n): void {\n  invariant(\n    mounted === expectedMounted,\n    `Invalid mounted state in ${context}: expected ${expectedMounted}, got ${mounted}`,\n    { mounted, expected: expectedMounted }\n  );\n}\n\n/**\n * Verify no null target when rendering\n * @internal\n */\nexport function assertRenderTarget(\n  target: Element | null,\n  context: string\n): asserts target is Element {\n  invariant(target !== null, `Cannot render in ${context}: target is null`, {\n    target,\n  });\n}\n","/**\n * Centralized logger interface\n * - Keeps production builds silent for debug/warn/info messages\n * - Ensures consistent behavior across the codebase\n * - Protects against missing `console` in some environments\n */\n\nfunction callConsole(method: string, args: unknown[]): void {\n  const c = typeof console !== 'undefined' ? (console as unknown) : undefined;\n  if (!c) return;\n  const fn = (c as Record<string, unknown>)[method];\n  if (typeof fn === 'function') {\n    try {\n      (fn as (...a: unknown[]) => unknown).apply(console, args as unknown[]);\n    } catch {\n      // ignore logging errors\n    }\n  }\n}\n\nexport const logger = {\n  debug: (...args: unknown[]) => {\n    if (process.env.NODE_ENV === 'production') return;\n    callConsole('debug', args);\n  },\n\n  info: (...args: unknown[]) => {\n    if (process.env.NODE_ENV === 'production') return;\n    callConsole('info', args);\n  },\n\n  warn: (...args: unknown[]) => {\n    if (process.env.NODE_ENV === 'production') return;\n    callConsole('warn', args);\n  },\n\n  error: (...args: unknown[]) => {\n    callConsole('error', args);\n  },\n};\n","/**\n * Serialized update scheduler — safer design (no inline execution, explicit flush)\n *\n * Key ideas:\n * - Never execute a task inline from `enqueue`.\n * - `flush()` is explicit and non-reentrant.\n * - `runWithSyncProgress()` allows enqueues temporarily but does not run tasks\n *   inline; it runs `fn` and then does an explicit `flush()`.\n * - `waitForFlush()` is race-free with a monotonic `flushVersion`.\n */\n\nimport { assertSchedulingPrecondition, invariant } from '../dev/invariant';\nimport { logger } from '../dev/logger';\n\nconst MAX_FLUSH_DEPTH = 50;\n\ntype Task = () => void;\n\nfunction isBulkCommitActive(): boolean {\n  try {\n    const fb = (\n      globalThis as {\n        __ASKR_FASTLANE?: { isBulkCommitActive?: () => boolean };\n      }\n    ).__ASKR_FASTLANE;\n    return typeof fb?.isBulkCommitActive === 'function'\n      ? !!fb.isBulkCommitActive()\n      : false;\n  } catch (e) {\n    void e;\n    return false;\n  }\n}\n\nexport class Scheduler {\n  private q: Task[] = [];\n  private head = 0;\n\n  private running = false;\n  private inHandler = false;\n  private depth = 0;\n  private executionDepth = 0; // for compat with existing diagnostics\n\n  // Monotonic flush version increments at end of each flush\n  private flushVersion = 0;\n\n  // Best-effort microtask kick scheduling\n  private kickScheduled = false;\n\n  // Escape hatch flag for runWithSyncProgress\n  private allowSyncProgress = false;\n\n  // Waiters waiting for flushVersion >= target\n  private waiters: Array<{\n    target: number;\n    resolve: () => void;\n    reject: (err: unknown) => void;\n    timer?: ReturnType<typeof setTimeout>;\n  }> = [];\n\n  // Keep a lightweight taskCount for compatibility/diagnostics\n  private taskCount = 0;\n\n  enqueue(task: Task): void {\n    assertSchedulingPrecondition(\n      typeof task === 'function',\n      'enqueue() requires a function'\n    );\n\n    // Strict rule: during bulk commit, only allow enqueues if runWithSyncProgress enabled\n    if (isBulkCommitActive() && !this.allowSyncProgress) {\n      if (process.env.NODE_ENV !== 'production') {\n        throw new Error(\n          '[Scheduler] enqueue() during bulk commit (not allowed)'\n        );\n      }\n      return;\n    }\n\n    // Enqueue task and account counts\n    this.q.push(task);\n    this.taskCount++;\n\n    // Microtask kick: best-effort, but avoid if we are in handler or running or bulk commit\n    if (\n      !this.running &&\n      !this.kickScheduled &&\n      !this.inHandler &&\n      !isBulkCommitActive()\n    ) {\n      this.kickScheduled = true;\n      queueMicrotask(() => {\n        this.kickScheduled = false;\n        if (this.running) return;\n        if (isBulkCommitActive()) return;\n        try {\n          this.flush();\n        } catch (err) {\n          setTimeout(() => {\n            throw err;\n          });\n        }\n      });\n    }\n  }\n\n  flush(): void {\n    invariant(\n      !this.running,\n      '[Scheduler] flush() called while already running'\n    );\n\n    // Dev-only guard: disallow flush during bulk commit unless allowed\n    if (process.env.NODE_ENV !== 'production') {\n      if (isBulkCommitActive() && !this.allowSyncProgress) {\n        throw new Error(\n          '[Scheduler] flush() started during bulk commit (not allowed)'\n        );\n      }\n    }\n\n    this.running = true;\n    this.depth = 0;\n    let fatal: unknown = null;\n\n    try {\n      while (this.head < this.q.length) {\n        this.depth++;\n        if (\n          process.env.NODE_ENV !== 'production' &&\n          this.depth > MAX_FLUSH_DEPTH\n        ) {\n          throw new Error(\n            `[Scheduler] exceeded MAX_FLUSH_DEPTH (${MAX_FLUSH_DEPTH}). Likely infinite update loop.`\n          );\n        }\n\n        const task = this.q[this.head++];\n        try {\n          this.executionDepth++;\n          task();\n          this.executionDepth--;\n        } catch (err) {\n          // ensure executionDepth stays balanced\n          if (this.executionDepth > 0) this.executionDepth = 0;\n          fatal = err;\n          break;\n        }\n\n        // Account for executed task in taskCount\n        if (this.taskCount > 0) this.taskCount--;\n      }\n    } finally {\n      this.running = false;\n      this.depth = 0;\n      this.executionDepth = 0;\n\n      // Compact queue\n      if (this.head >= this.q.length) {\n        this.q.length = 0;\n        this.head = 0;\n      } else if (this.head > 0) {\n        const remaining = this.q.length - this.head;\n        // HOT PATH: compact in-place to avoid slice() allocations (GC tail spikes)\n        for (let i = 0; i < remaining; i++) {\n          this.q[i] = this.q[this.head + i];\n        }\n        this.q.length = remaining;\n        this.head = 0;\n      }\n\n      // Advance flush epoch and resolve waiters\n      this.flushVersion++;\n      this.resolveWaiters();\n    }\n\n    if (fatal) throw fatal;\n  }\n\n  runWithSyncProgress<T>(fn: () => T): T {\n    const prev = this.allowSyncProgress;\n    this.allowSyncProgress = true;\n\n    const g = globalThis as {\n      queueMicrotask?: (...args: unknown[]) => void;\n      setTimeout?: (...args: unknown[]) => unknown;\n    };\n    const origQueueMicrotask = g.queueMicrotask;\n    const origSetTimeout = g.setTimeout;\n\n    if (process.env.NODE_ENV !== 'production') {\n      g.queueMicrotask = () => {\n        throw new Error(\n          '[Scheduler] queueMicrotask not allowed during runWithSyncProgress'\n        );\n      };\n      g.setTimeout = () => {\n        throw new Error(\n          '[Scheduler] setTimeout not allowed during runWithSyncProgress'\n        );\n      };\n    }\n\n    // Snapshot flushVersion so we can ensure we always complete an epoch\n    const startVersion = this.flushVersion;\n\n    try {\n      const res = fn();\n\n      // Flush deterministically if tasks were enqueued (and we're not already running)\n      if (!this.running && this.q.length - this.head > 0) {\n        this.flush();\n      }\n\n      if (process.env.NODE_ENV !== 'production') {\n        if (this.q.length - this.head > 0) {\n          throw new Error(\n            '[Scheduler] tasks remain after runWithSyncProgress flush'\n          );\n        }\n      }\n\n      return res;\n    } finally {\n      // Restore guarded globals\n      if (process.env.NODE_ENV !== 'production') {\n        g.queueMicrotask = origQueueMicrotask;\n        g.setTimeout = origSetTimeout;\n      }\n\n      // If no flush happened during the protected window, complete an epoch so\n      // observers (tests) see progress even when fast-lane did synchronous work\n      // without enqueuing tasks.\n      try {\n        if (this.flushVersion === startVersion) {\n          this.flushVersion++;\n          this.resolveWaiters();\n        }\n      } catch (e) {\n        void e;\n      }\n\n      this.allowSyncProgress = prev;\n    }\n  }\n\n  waitForFlush(targetVersion?: number, timeoutMs = 2000): Promise<void> {\n    const target =\n      typeof targetVersion === 'number' ? targetVersion : this.flushVersion + 1;\n    if (this.flushVersion >= target) return Promise.resolve();\n\n    return new Promise((resolve, reject) => {\n      const timer = setTimeout(() => {\n        const ns =\n          (\n            globalThis as unknown as Record<string, unknown> & {\n              __ASKR__?: Record<string, unknown>;\n            }\n          ).__ASKR__ || {};\n        const diag = {\n          flushVersion: this.flushVersion,\n          queueLen: this.q.length - this.head,\n          running: this.running,\n          inHandler: this.inHandler,\n          bulk: isBulkCommitActive(),\n          namespace: ns,\n        };\n        reject(\n          new Error(\n            `waitForFlush timeout ${timeoutMs}ms: ${JSON.stringify(diag)}`\n          )\n        );\n      }, timeoutMs);\n\n      this.waiters.push({ target, resolve, reject, timer });\n    });\n  }\n\n  getState() {\n    // Provide the compatibility shape expected by diagnostics/tests\n    return {\n      queueLength: this.q.length - this.head,\n      running: this.running,\n      depth: this.depth,\n      executionDepth: this.executionDepth,\n      taskCount: this.taskCount,\n      flushVersion: this.flushVersion,\n      // New fields for optional inspection\n      inHandler: this.inHandler,\n      allowSyncProgress: this.allowSyncProgress,\n    };\n  }\n\n  setInHandler(v: boolean) {\n    this.inHandler = v;\n  }\n\n  isInHandler(): boolean {\n    return this.inHandler;\n  }\n\n  isExecuting(): boolean {\n    return this.running || this.executionDepth > 0;\n  }\n\n  // Clear pending synchronous tasks (used by fastlane enter/exit)\n  clearPendingSyncTasks(): number {\n    const remaining = this.q.length - this.head;\n    if (remaining <= 0) return 0;\n\n    if (this.running) {\n      this.q.length = this.head;\n      this.taskCount = Math.max(0, this.taskCount - remaining);\n      queueMicrotask(() => {\n        try {\n          this.flushVersion++;\n          this.resolveWaiters();\n        } catch (e) {\n          void e;\n        }\n      });\n      return remaining;\n    }\n\n    this.q.length = 0;\n    this.head = 0;\n    this.taskCount = Math.max(0, this.taskCount - remaining);\n    this.flushVersion++;\n    this.resolveWaiters();\n    return remaining;\n  }\n\n  private resolveWaiters() {\n    if (this.waiters.length === 0) return;\n    const ready: Array<() => void> = [];\n    const remaining: typeof this.waiters = [];\n\n    for (const w of this.waiters) {\n      if (this.flushVersion >= w.target) {\n        if (w.timer) clearTimeout(w.timer);\n        ready.push(w.resolve);\n      } else {\n        remaining.push(w);\n      }\n    }\n\n    this.waiters = remaining;\n    for (const r of ready) r();\n  }\n}\n\nexport const globalScheduler = new Scheduler();\n\nexport function isSchedulerExecuting(): boolean {\n  return globalScheduler.isExecuting();\n}\n\nexport function scheduleEventHandler(handler: EventListener): EventListener {\n  return (event: Event) => {\n    globalScheduler.setInHandler(true);\n    try {\n      handler.call(null, event);\n    } catch (error) {\n      logger.error('[Askr] Event handler error:', error);\n    } finally {\n      globalScheduler.setInHandler(false);\n      // If the handler enqueued tasks while we disallowed microtask kicks,\n      // ensure we schedule a microtask to flush them now that the handler\n      // has completed. This avoids tests timing out waiting for flush.\n      const state = globalScheduler.getState();\n      if ((state.queueLength ?? 0) > 0 && !state.running) {\n        queueMicrotask(() => {\n          try {\n            if (!globalScheduler.isExecuting()) globalScheduler.flush();\n          } catch (err) {\n            setTimeout(() => {\n              throw err;\n            });\n          }\n        });\n      }\n    }\n  };\n}\n","// Lightweight shared no-op helpers to avoid double-casts and duplicated definitions\n\nexport const noop: () => void = () => {};\n\nexport const noopEventListener: EventListener & { cancel(): void } =\n  Object.assign((_ev?: Event) => {}, { cancel() {} });\n\nexport const noopEventListenerWithFlush: EventListener & {\n  cancel(): void;\n  flush(): void;\n} = Object.assign((_ev?: Event) => {}, { cancel() {}, flush() {} });\n\nexport const noopCancel: { cancel(): void } = { cancel() {} };\n","import { globalScheduler } from '../runtime/scheduler';\nimport { getCurrentComponentInstance } from '../runtime/component';\nimport { logger } from '../dev/logger';\nimport { noopEventListener, noopEventListenerWithFlush } from './noop';\n\nexport type CancelFn = () => void;\n\n// Platform-specific timer handle types\ntype TimeoutHandle = ReturnType<typeof setTimeout> | null;\n// rAF may fall back to setTimeout in some environments/tests, include both\ntype RafHandle =\n  | ReturnType<typeof requestAnimationFrame>\n  | ReturnType<typeof setTimeout>\n  | null;\n// requestIdleCallback may be unavailable; allow setTimeout fallback handle\ntype IdleHandle =\n  | ReturnType<typeof requestIdleCallback>\n  | ReturnType<typeof setTimeout>\n  | null;\n\nfunction throwIfDuringRender(): void {\n  const inst = getCurrentComponentInstance();\n  if (inst !== null) {\n    throw new Error(\n      '[Askr] calling FX handler during render is not allowed. Move calls to event handlers or effects.'\n    );\n  }\n}\n\n/**\n * Helper: schedule a user callback through the global scheduler\n */\nfunction enqueueUserCallback(fn: () => void) {\n  globalScheduler.enqueue(() => {\n    try {\n      fn();\n    } catch (err) {\n      // Keep behavior consistent with other scheduler-queued work\n      logger.error('[Askr] FX handler error:', err);\n    }\n  });\n}\n\n// ---------- Event handlers ----------\n\nexport function debounceEvent(\n  ms: number,\n  handler: EventListener,\n  options?: { leading?: boolean; trailing?: boolean }\n): EventListener & { cancel(): void; flush(): void } {\n  const { leading = false, trailing = true } = options || {};\n\n  const inst = getCurrentComponentInstance();\n  // On SSR, event handlers are inert\n  if (inst && inst.ssr) {\n    return noopEventListenerWithFlush;\n  }\n\n  let timeoutId: TimeoutHandle = null;\n  let lastEvent: Event | null = null;\n  let lastCallTime = 0;\n\n  const debounced = function (this: unknown, ev: Event) {\n    // Disallow using returned handler during render\n    throwIfDuringRender();\n\n    const now = Date.now();\n    lastEvent = ev;\n\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n\n    if (leading && now - lastCallTime >= ms) {\n      enqueueUserCallback(() => handler.call(null, ev));\n      lastCallTime = now;\n    }\n\n    if (trailing) {\n      timeoutId = setTimeout(() => {\n        // Schedule through scheduler\n        if (lastEvent) {\n          enqueueUserCallback(() => handler.call(null, lastEvent!));\n        }\n        timeoutId = null;\n        lastCallTime = Date.now();\n      }, ms);\n    }\n  } as EventListener & { cancel(): void; flush(): void };\n\n  debounced.cancel = () => {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n    lastEvent = null;\n  };\n\n  debounced.flush = () => {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      const ev = lastEvent;\n      lastEvent = null;\n      timeoutId = null;\n      if (ev) enqueueUserCallback(() => handler.call(null, ev));\n    }\n  };\n\n  // Auto-cleanup on component unmount\n  if (inst) {\n    inst.cleanupFns.push(() => {\n      debounced.cancel();\n    });\n  }\n\n  return debounced;\n}\n\nexport function throttleEvent(\n  ms: number,\n  handler: EventListener,\n  options?: { leading?: boolean; trailing?: boolean }\n): EventListener & { cancel(): void } {\n  const { leading = true, trailing = true } = options || {};\n\n  const inst = getCurrentComponentInstance();\n  if (inst && inst.ssr) {\n    return noopEventListener;\n  }\n\n  let lastCallTime = 0;\n  let timeoutId: TimeoutHandle = null;\n  let lastEvent: Event | null = null;\n\n  const throttled = function (this: unknown, ev: Event) {\n    throwIfDuringRender();\n\n    const now = Date.now();\n    lastEvent = ev;\n\n    if (leading && now - lastCallTime >= ms) {\n      enqueueUserCallback(() => handler.call(null, ev));\n      lastCallTime = now;\n      if (timeoutId !== null) {\n        clearTimeout(timeoutId);\n        timeoutId = null;\n      }\n    } else if (!leading && lastCallTime === 0) {\n      lastCallTime = now;\n    }\n\n    if (trailing && timeoutId === null) {\n      const wait = ms - (now - lastCallTime);\n      timeoutId = setTimeout(\n        () => {\n          if (lastEvent)\n            enqueueUserCallback(() => handler.call(null, lastEvent!));\n          lastCallTime = Date.now();\n          timeoutId = null;\n        },\n        Math.max(0, wait)\n      );\n    }\n  } as EventListener & { cancel(): void };\n\n  throttled.cancel = () => {\n    if (timeoutId !== null) {\n      clearTimeout(timeoutId);\n      timeoutId = null;\n    }\n    lastEvent = null;\n  };\n\n  if (inst) {\n    inst.cleanupFns.push(() => throttled.cancel());\n  }\n\n  return throttled;\n}\n\nexport function rafEvent(\n  handler: EventListener\n): EventListener & { cancel(): void } {\n  const inst = getCurrentComponentInstance();\n  if (inst && inst.ssr) {\n    return noopEventListener;\n  }\n\n  let frameId: RafHandle = null;\n  let lastEvent: Event | null = null;\n\n  const scheduleFrame = () => {\n    const rAF =\n      typeof requestAnimationFrame !== 'undefined'\n        ? requestAnimationFrame\n        : (cb: FrameRequestCallback) => setTimeout(() => cb(Date.now()), 16);\n\n    frameId = rAF(() => {\n      frameId = null;\n      if (lastEvent) {\n        const ev = lastEvent;\n        lastEvent = null;\n        enqueueUserCallback(() => handler.call(null, ev));\n      }\n    });\n  };\n\n  const fn = function (this: unknown, ev: Event) {\n    throwIfDuringRender();\n    lastEvent = ev;\n    if (frameId === null) scheduleFrame();\n  } as EventListener & { cancel(): void };\n\n  fn.cancel = () => {\n    if (frameId !== null) {\n      // If frameId is numeric and cancelAnimationFrame is available, use it;\n      // otherwise fall back to clearTimeout for the setTimeout fallback.\n      if (\n        typeof cancelAnimationFrame !== 'undefined' &&\n        typeof frameId === 'number'\n      ) {\n        cancelAnimationFrame(frameId);\n      } else {\n        clearTimeout(frameId as ReturnType<typeof setTimeout>);\n      }\n      frameId = null;\n    }\n    lastEvent = null;\n  };\n\n  if (inst) inst.cleanupFns.push(() => fn.cancel());\n\n  return fn;\n}\n\n// ---------- Scheduled work ----------\n\nexport function scheduleTimeout(ms: number, fn: () => void): CancelFn {\n  throwIfDuringRender();\n  const inst = getCurrentComponentInstance();\n  if (inst && inst.ssr) {\n    return () => {};\n  }\n\n  let id: TimeoutHandle = setTimeout(() => {\n    id = null;\n    enqueueUserCallback(fn);\n  }, ms);\n\n  const cancel = () => {\n    if (id !== null) {\n      clearTimeout(id);\n      id = null;\n    }\n  };\n\n  if (inst) inst.cleanupFns.push(cancel);\n  return cancel;\n}\n\nexport function scheduleIdle(\n  fn: () => void,\n  options?: { timeout?: number }\n): CancelFn {\n  throwIfDuringRender();\n  const inst = getCurrentComponentInstance();\n  if (inst && inst.ssr) return () => {};\n\n  let id: IdleHandle = null;\n  let usingRIC = false;\n\n  if (typeof requestIdleCallback !== 'undefined') {\n    usingRIC = true;\n    id = requestIdleCallback(() => {\n      id = null;\n      enqueueUserCallback(fn);\n    }, options);\n  } else {\n    // Fallback: schedule on next macrotask\n    id = setTimeout(() => {\n      id = null;\n      enqueueUserCallback(fn);\n    }, 0);\n  }\n\n  const cancel = () => {\n    if (id !== null) {\n      // If using requestIdleCallback and available, call cancelIdleCallback for numeric ids.\n      if (\n        usingRIC &&\n        typeof cancelIdleCallback !== 'undefined' &&\n        typeof id === 'number'\n      ) {\n        cancelIdleCallback(id);\n      } else {\n        clearTimeout(id as ReturnType<typeof setTimeout>);\n      }\n      id = null;\n    }\n  };\n\n  if (inst) inst.cleanupFns.push(cancel);\n  return cancel;\n}\n\nexport interface RetryOptions {\n  maxAttempts?: number;\n  delayMs?: number;\n  backoff?: (attemptIndex: number) => number;\n}\n\nexport function scheduleRetry<T>(\n  fn: () => Promise<T>,\n  options?: RetryOptions\n): { cancel(): void } {\n  throwIfDuringRender();\n  const inst = getCurrentComponentInstance();\n  if (inst && inst.ssr) return { cancel: () => {} };\n\n  const {\n    maxAttempts = 3,\n    delayMs = 100,\n    backoff = (i: number) => delayMs * Math.pow(2, i),\n  } = options || {};\n\n  let cancelled = false;\n\n  const attempt = (index: number) => {\n    if (cancelled) return;\n    // Run user fn inside scheduler\n    globalScheduler.enqueue(() => {\n      if (cancelled) return;\n      // Call fn (it may be async)\n      const p = fn();\n      p.then(\n        () => {\n          // Completed successfully\n        },\n        () => {\n          if (cancelled) return;\n          if (index + 1 < maxAttempts) {\n            const delay = backoff(index);\n            // Schedule next attempt via setTimeout so it gets enqueued through scheduleTimeout\n            setTimeout(() => {\n              attempt(index + 1);\n            }, delay);\n          }\n        }\n      ).catch((e) => {\n        logger.error('[Askr] scheduleRetry error:', e);\n      });\n    });\n  };\n\n  // Start first attempt\n  attempt(0);\n\n  const cancel = () => {\n    cancelled = true;\n  };\n\n  if (inst) inst.cleanupFns.push(cancel);\n  return { cancel };\n}\n"]}