@ai-matrx/kit 0.5.0

package/dist/idle-scheduler.d.cts

@@ -0,0 +1,185 @@
+/**
+ * IdleScheduler — a priority-aware deferred execution system for browser apps.
+ *
+ * Architecture:
+ * - Process-wide singleton (NOT React context) — registrations cause zero re-renders
+ * - Components register lightweight callbacks with priority 1-5
+ * - The scheduler waits for the browser to be truly idle after full page render
+ * - Then flushes all registered callbacks in priority order
+ *
+ * Priority levels:
+ *   1 = Highest (first of the "last things") — e.g., analytics init, critical measurements
+ *   2 = High — e.g., prefetching next-page data, service worker registration
+ *   3 = Normal — e.g., lazy-loading non-critical UI, initializing 3rd party widgets
+ *   4 = Low — e.g., telemetry, background sync setup
+ *   5 = Lowest (absolute last) — e.g., prewarming caches, speculative prefetch
+ *
+ * Cross-browser idle detection chain:
+ *   document.readyState === 'complete'
+ *     → requestAnimationFrame (past next paint)
+ *       → scheduler.postTask({ priority: 'background' })  [Chrome/Edge/Firefox 142+]
+ *       → requestIdleCallback                              [Chrome/Firefox, NOT Safari]
+ *       → MessageChannel postMessage                       [Universal — React's own trick]
+ *
+ * Ported from matrx-frontend `utils/idle-scheduler/idle-scheduler.ts`, with
+ * TWO structural inversions, behavior otherwise verbatim:
+ * - Scheduler state (queue, flush state, cleanups, listeners) lives on
+ *   `globalThis` under `Symbol.for("ai-matrx.kit.idle-scheduler-state")`
+ *   instead of module-level variables. With the package built
+ *   `splitting: false` in dual ESM/CJS format this module is duplicated into
+ *   the root and `./idle-scheduler` bundles, and CJS/ESM each instantiate
+ *   their own module graph — module-level state would silently split the
+ *   flush pipeline from some registrants (the confirm-opener hazard). Never
+ *   "clean this up" into module locals.
+ * - The `window.__idleSched()` diagnostics probe installs on first API use
+ *   instead of at module evaluation, keeping every entry point import-time
+ *   inert (the package standard). The probe itself is unchanged.
+ */
+type IdlePriority = 1 | 2 | 3 | 4 | 5;
+interface IdleRegistration {
+    /** Unique key for deduplication and cancellation */
+    key: string;
+    /** 1 = highest (first to run), 5 = lowest (last to run) */
+    priority: IdlePriority;
+    /** The deferred work */
+    callback: () => void | Promise<void>;
+}
+type UnregisterFn = () => void;
+type FlushState = "idle" | "waiting" | "flushing" | "done";
+/**
+ * Register a callback to run after the page is fully idle.
+ *
+ * - If the scheduler hasn't flushed yet: queues the callback.
+ * - If the scheduler already flushed: runs the callback immediately
+ *   (through the same idle detection chain, so it still won't block).
+ *
+ * Returns an unregister function for cleanup.
+ */
+declare function registerIdleTask(key: string, priority: IdlePriority, callback: () => void | Promise<void>): UnregisterFn;
+/**
+ * Subscribe to the flush-complete event.
+ * Useful for components that just need a "ready" signal without registering work.
+ */
+declare function onFlushComplete(listener: () => void): UnregisterFn;
+/**
+ * Resolve after the initial page-load idle flush, or earlier when aborted.
+ * Non-React startup services use this instead of recreating the scheduler's
+ * load → paint → browser-idle detection chain.
+ *
+ * @returns false when the caller aborted before idle; true otherwise.
+ */
+declare function whenPageIdle(signal?: AbortSignal): Promise<boolean>;
+/**
+ * Get current state — useful for debugging or conditional logic.
+ */
+declare function getSchedulerState(): {
+    flushState: FlushState;
+    pendingCount: number;
+    pendingKeys: string[];
+};
+/**
+ * Reset the scheduler — primarily for testing or hot-reload scenarios.
+ */
+declare function resetScheduler(): void;
+
+/**
+ * React hooks for the IdleScheduler.
+ *
+ * These are intentionally thin — they just wire up registration/cleanup
+ * to React's lifecycle. No state, no context, no re-renders on registration.
+ *
+ * Three hooks for three use cases:
+ *
+ * 1. useIdleTask(key, priority, callback)
+ *    → "Run this callback when idle. I don't need to know when."
+ *    → Fire-and-forget. Zero re-renders.
+ *
+ * 2. useIdleReady()
+ *    → "Just tell me when idle flush is done so I can wake up."
+ *    → Returns a boolean. One re-render: false → true.
+ *
+ * 3. useIdleGate(key, priority, callback)
+ *    → "Run this callback when idle AND tell me when it's done."
+ *    → Returns { ready: boolean }. Combines both patterns.
+ *
+ * Plus useIdleRegister() for imperative/conditional registration.
+ *
+ * Ported verbatim from matrx-frontend `utils/idle-scheduler/hooks.ts`.
+ */
+
+/**
+ * Register a callback to execute after page idle. Zero re-renders.
+ *
+ * @param key   Unique identifier (for deduplication/cancellation)
+ * @param priority  1 (first of last) through 5 (absolute last)
+ * @param callback  The deferred work
+ *
+ * @example
+ * ```tsx
+ * useIdleTask('analytics-init', 3, () => {
+ *   initializeAnalytics();
+ * });
+ * ```
+ */
+declare function useIdleTask(key: string, priority: IdlePriority, callback: () => void | Promise<void>): void;
+/**
+ * Returns `true` once the idle flush has completed.
+ * Causes exactly one re-render (false → true). No work is registered.
+ *
+ * Use this when a component wants to stay dormant (show nothing, or a skeleton)
+ * until the page is fully settled, then "turn on."
+ *
+ * @example
+ * ```tsx
+ * function HeavyWidget() {
+ *   const ready = useIdleReady();
+ *   if (!ready) return null; // or a skeleton
+ *   return <ExpensiveComponent />;
+ * }
+ * ```
+ */
+declare function useIdleReady(): boolean;
+/**
+ * Register deferred work and get a `ready` signal when it completes.
+ *
+ * This is the "full package" — your component stays dormant, the scheduler
+ * runs your callback at the right time, and then you get notified to
+ * update your UI.
+ *
+ * @example
+ * ```tsx
+ * function PrefetchedSection() {
+ *   const { ready } = useIdleGate('prefetch-recommendations', 2, async () => {
+ *     await prefetchRecommendations();
+ *   });
+ *
+ *   if (!ready) return <Skeleton />;
+ *   return <Recommendations />;
+ * }
+ * ```
+ */
+declare function useIdleGate(key: string, priority: IdlePriority, callback: () => void | Promise<void>): {
+    ready: boolean;
+};
+/**
+ * Returns a `register` function you can call imperatively.
+ * Useful when the deferred work depends on runtime conditions.
+ *
+ * @example
+ * ```tsx
+ * function SearchResults({ query }) {
+ *   const scheduleIdle = useIdleRegister();
+ *
+ *   useEffect(() => {
+ *     if (query) {
+ *       scheduleIdle(`prefetch-${query}`, 4, () => {
+ *         prefetchRelatedResults(query);
+ *       });
+ *     }
+ *   }, [query, scheduleIdle]);
+ * }
+ * ```
+ */
+declare function useIdleRegister(): (key: string, priority: IdlePriority, callback: () => void | Promise<void>) => void;
+
+export { type FlushState, type IdlePriority, type IdleRegistration, type UnregisterFn, getSchedulerState, onFlushComplete, registerIdleTask, resetScheduler, useIdleGate, useIdleReady, useIdleRegister, useIdleTask, whenPageIdle };

package/dist/idle-scheduler.d.ts

@@ -0,0 +1,185 @@
+/**
+ * IdleScheduler — a priority-aware deferred execution system for browser apps.
+ *
+ * Architecture:
+ * - Process-wide singleton (NOT React context) — registrations cause zero re-renders
+ * - Components register lightweight callbacks with priority 1-5
+ * - The scheduler waits for the browser to be truly idle after full page render
+ * - Then flushes all registered callbacks in priority order
+ *
+ * Priority levels:
+ *   1 = Highest (first of the "last things") — e.g., analytics init, critical measurements
+ *   2 = High — e.g., prefetching next-page data, service worker registration
+ *   3 = Normal — e.g., lazy-loading non-critical UI, initializing 3rd party widgets
+ *   4 = Low — e.g., telemetry, background sync setup
+ *   5 = Lowest (absolute last) — e.g., prewarming caches, speculative prefetch
+ *
+ * Cross-browser idle detection chain:
+ *   document.readyState === 'complete'
+ *     → requestAnimationFrame (past next paint)
+ *       → scheduler.postTask({ priority: 'background' })  [Chrome/Edge/Firefox 142+]
+ *       → requestIdleCallback                              [Chrome/Firefox, NOT Safari]
+ *       → MessageChannel postMessage                       [Universal — React's own trick]
+ *
+ * Ported from matrx-frontend `utils/idle-scheduler/idle-scheduler.ts`, with
+ * TWO structural inversions, behavior otherwise verbatim:
+ * - Scheduler state (queue, flush state, cleanups, listeners) lives on
+ *   `globalThis` under `Symbol.for("ai-matrx.kit.idle-scheduler-state")`
+ *   instead of module-level variables. With the package built
+ *   `splitting: false` in dual ESM/CJS format this module is duplicated into
+ *   the root and `./idle-scheduler` bundles, and CJS/ESM each instantiate
+ *   their own module graph — module-level state would silently split the
+ *   flush pipeline from some registrants (the confirm-opener hazard). Never
+ *   "clean this up" into module locals.
+ * - The `window.__idleSched()` diagnostics probe installs on first API use
+ *   instead of at module evaluation, keeping every entry point import-time
+ *   inert (the package standard). The probe itself is unchanged.
+ */
+type IdlePriority = 1 | 2 | 3 | 4 | 5;
+interface IdleRegistration {
+    /** Unique key for deduplication and cancellation */
+    key: string;
+    /** 1 = highest (first to run), 5 = lowest (last to run) */
+    priority: IdlePriority;
+    /** The deferred work */
+    callback: () => void | Promise<void>;
+}
+type UnregisterFn = () => void;
+type FlushState = "idle" | "waiting" | "flushing" | "done";
+/**
+ * Register a callback to run after the page is fully idle.
+ *
+ * - If the scheduler hasn't flushed yet: queues the callback.
+ * - If the scheduler already flushed: runs the callback immediately
+ *   (through the same idle detection chain, so it still won't block).
+ *
+ * Returns an unregister function for cleanup.
+ */
+declare function registerIdleTask(key: string, priority: IdlePriority, callback: () => void | Promise<void>): UnregisterFn;
+/**
+ * Subscribe to the flush-complete event.
+ * Useful for components that just need a "ready" signal without registering work.
+ */
+declare function onFlushComplete(listener: () => void): UnregisterFn;
+/**
+ * Resolve after the initial page-load idle flush, or earlier when aborted.
+ * Non-React startup services use this instead of recreating the scheduler's
+ * load → paint → browser-idle detection chain.
+ *
+ * @returns false when the caller aborted before idle; true otherwise.
+ */
+declare function whenPageIdle(signal?: AbortSignal): Promise<boolean>;
+/**
+ * Get current state — useful for debugging or conditional logic.
+ */
+declare function getSchedulerState(): {
+    flushState: FlushState;
+    pendingCount: number;
+    pendingKeys: string[];
+};
+/**
+ * Reset the scheduler — primarily for testing or hot-reload scenarios.
+ */
+declare function resetScheduler(): void;
+
+/**
+ * React hooks for the IdleScheduler.
+ *
+ * These are intentionally thin — they just wire up registration/cleanup
+ * to React's lifecycle. No state, no context, no re-renders on registration.
+ *
+ * Three hooks for three use cases:
+ *
+ * 1. useIdleTask(key, priority, callback)
+ *    → "Run this callback when idle. I don't need to know when."
+ *    → Fire-and-forget. Zero re-renders.
+ *
+ * 2. useIdleReady()
+ *    → "Just tell me when idle flush is done so I can wake up."
+ *    → Returns a boolean. One re-render: false → true.
+ *
+ * 3. useIdleGate(key, priority, callback)
+ *    → "Run this callback when idle AND tell me when it's done."
+ *    → Returns { ready: boolean }. Combines both patterns.
+ *
+ * Plus useIdleRegister() for imperative/conditional registration.
+ *
+ * Ported verbatim from matrx-frontend `utils/idle-scheduler/hooks.ts`.
+ */
+
+/**
+ * Register a callback to execute after page idle. Zero re-renders.
+ *
+ * @param key   Unique identifier (for deduplication/cancellation)
+ * @param priority  1 (first of last) through 5 (absolute last)
+ * @param callback  The deferred work
+ *
+ * @example
+ * ```tsx
+ * useIdleTask('analytics-init', 3, () => {
+ *   initializeAnalytics();
+ * });
+ * ```
+ */
+declare function useIdleTask(key: string, priority: IdlePriority, callback: () => void | Promise<void>): void;
+/**
+ * Returns `true` once the idle flush has completed.
+ * Causes exactly one re-render (false → true). No work is registered.
+ *
+ * Use this when a component wants to stay dormant (show nothing, or a skeleton)
+ * until the page is fully settled, then "turn on."
+ *
+ * @example
+ * ```tsx
+ * function HeavyWidget() {
+ *   const ready = useIdleReady();
+ *   if (!ready) return null; // or a skeleton
+ *   return <ExpensiveComponent />;
+ * }
+ * ```
+ */
+declare function useIdleReady(): boolean;
+/**
+ * Register deferred work and get a `ready` signal when it completes.
+ *
+ * This is the "full package" — your component stays dormant, the scheduler
+ * runs your callback at the right time, and then you get notified to
+ * update your UI.
+ *
+ * @example
+ * ```tsx
+ * function PrefetchedSection() {
+ *   const { ready } = useIdleGate('prefetch-recommendations', 2, async () => {
+ *     await prefetchRecommendations();
+ *   });
+ *
+ *   if (!ready) return <Skeleton />;
+ *   return <Recommendations />;
+ * }
+ * ```
+ */
+declare function useIdleGate(key: string, priority: IdlePriority, callback: () => void | Promise<void>): {
+    ready: boolean;
+};
+/**
+ * Returns a `register` function you can call imperatively.
+ * Useful when the deferred work depends on runtime conditions.
+ *
+ * @example
+ * ```tsx
+ * function SearchResults({ query }) {
+ *   const scheduleIdle = useIdleRegister();
+ *
+ *   useEffect(() => {
+ *     if (query) {
+ *       scheduleIdle(`prefetch-${query}`, 4, () => {
+ *         prefetchRelatedResults(query);
+ *       });
+ *     }
+ *   }, [query, scheduleIdle]);
+ * }
+ * ```
+ */
+declare function useIdleRegister(): (key: string, priority: IdlePriority, callback: () => void | Promise<void>) => void;
+
+export { type FlushState, type IdlePriority, type IdleRegistration, type UnregisterFn, getSchedulerState, onFlushComplete, registerIdleTask, resetScheduler, useIdleGate, useIdleReady, useIdleRegister, useIdleTask, whenPageIdle };

package/dist/idle-scheduler.js

@@ -0,0 +1,246 @@
+"use client";
+
+// src/idle-scheduler/scheduler.ts
+var STATE_SLOT = /* @__PURE__ */ Symbol.for("ai-matrx.kit.idle-scheduler-state");
+function getState() {
+  const holder = globalThis;
+  let state = holder[STATE_SLOT];
+  if (!state) {
+    state = {
+      queue: /* @__PURE__ */ new Map(),
+      flushState: "idle",
+      cleanupFns: [],
+      flushListeners: /* @__PURE__ */ new Set()
+    };
+    holder[STATE_SLOT] = state;
+    if (typeof window !== "undefined") {
+      window.__idleSched = getSchedulerState;
+    }
+  }
+  return state;
+}
+function registerIdleTask(key, priority, callback) {
+  const state = getState();
+  if (state.flushState === "done") {
+    scheduleImmediate(callback);
+    return () => {
+    };
+  }
+  state.queue.set(key, { key, priority, callback });
+  if (state.flushState === "idle") {
+    startFlushPipeline(state);
+  }
+  return () => {
+    state.queue.delete(key);
+  };
+}
+function onFlushComplete(listener) {
+  const state = getState();
+  if (state.flushState === "done") {
+    queueMicrotask(listener);
+    return () => {
+    };
+  }
+  state.flushListeners.add(listener);
+  if (state.flushState === "idle") {
+    startFlushPipeline(state);
+  }
+  return () => {
+    state.flushListeners.delete(listener);
+  };
+}
+function whenPageIdle(signal) {
+  if (signal?.aborted) return Promise.resolve(false);
+  return new Promise((resolve) => {
+    let settled = false;
+    let unsubscribe = () => {
+    };
+    const finish = (ready) => {
+      if (settled) return;
+      settled = true;
+      unsubscribe();
+      signal?.removeEventListener("abort", onAbort);
+      resolve(ready);
+    };
+    const onAbort = () => finish(false);
+    unsubscribe = onFlushComplete(() => finish(true));
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function getSchedulerState() {
+  const state = getState();
+  return {
+    flushState: state.flushState,
+    pendingCount: state.queue.size,
+    pendingKeys: Array.from(state.queue.keys())
+  };
+}
+function resetScheduler() {
+  const state = getState();
+  state.cleanupFns.forEach((fn) => fn());
+  state.cleanupFns = [];
+  state.queue.clear();
+  state.flushListeners.clear();
+  state.flushState = "idle";
+}
+function startFlushPipeline(state) {
+  if (typeof window === "undefined") return;
+  state.flushState = "waiting";
+  const waitForLoad = () => {
+    if (document.readyState === "complete") {
+      waitForPaint();
+    } else {
+      const onLoad = () => waitForPaint();
+      window.addEventListener("load", onLoad, { once: true });
+      state.cleanupFns.push(() => window.removeEventListener("load", onLoad));
+    }
+  };
+  const waitForPaint = () => {
+    let advanced = false;
+    const advance = () => {
+      if (advanced) return;
+      advanced = true;
+      waitForIdle();
+    };
+    const rafId = requestAnimationFrame(advance);
+    const timeoutId = setTimeout(
+      advance,
+      document.visibilityState === "hidden" ? 250 : 1500
+    );
+    state.cleanupFns.push(() => {
+      cancelAnimationFrame(rafId);
+      clearTimeout(timeoutId);
+    });
+  };
+  const waitForIdle = () => {
+    const schedulerGlobal = globalThis.scheduler;
+    if (schedulerGlobal && "postTask" in schedulerGlobal) {
+      schedulerGlobal.postTask(() => void flush(state), { priority: "background" }).catch(() => {
+      });
+      return;
+    }
+    if ("requestIdleCallback" in window) {
+      const idleId = requestIdleCallback(() => void flush(state));
+      state.cleanupFns.push(() => cancelIdleCallback(idleId));
+      return;
+    }
+    const channel = new MessageChannel();
+    channel.port1.onmessage = () => void flush(state);
+    channel.port2.postMessage(void 0);
+  };
+  waitForLoad();
+}
+async function flush(state) {
+  if (state.flushState === "done" || state.flushState === "flushing") return;
+  state.flushState = "flushing";
+  const sorted = Array.from(state.queue.values()).sort(
+    (a, b) => a.priority - b.priority
+  );
+  state.queue.clear();
+  for (const task of sorted) {
+    try {
+      await task.callback();
+    } catch (err) {
+      console.error(`[IdleScheduler] Task "${task.key}" failed:`, err);
+    }
+  }
+  state.flushState = "done";
+  if (state.queue.size > 0) {
+    const late = Array.from(state.queue.values()).sort(
+      (a, b) => a.priority - b.priority
+    );
+    state.queue.clear();
+    for (const task of late) scheduleImmediate(task.callback);
+  }
+  state.flushListeners.forEach((listener) => {
+    try {
+      listener();
+    } catch (err) {
+      console.error("[IdleScheduler] Flush listener failed:", err);
+    }
+  });
+  state.flushListeners.clear();
+}
+function scheduleImmediate(callback) {
+  requestAnimationFrame(() => {
+    const schedulerGlobal = globalThis.scheduler;
+    if (schedulerGlobal && "postTask" in schedulerGlobal) {
+      schedulerGlobal.postTask(() => void callback(), { priority: "background" }).catch(() => {
+      });
+      return;
+    }
+    if ("requestIdleCallback" in window) {
+      requestIdleCallback(() => void callback());
+      return;
+    }
+    const channel = new MessageChannel();
+    channel.port1.onmessage = () => void callback();
+    channel.port2.postMessage(void 0);
+  });
+}
+
+// src/idle-scheduler/hooks.ts
+import { useEffect, useRef, useState, useCallback } from "react";
+function useIdleTask(key, priority, callback) {
+  const callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  useEffect(() => {
+    const unregister = registerIdleTask(key, priority, () => {
+      return callbackRef.current();
+    });
+    return unregister;
+  }, [key, priority]);
+}
+function useIdleReady() {
+  const [ready, setReady] = useState(false);
+  useEffect(() => {
+    const unsubscribe = onFlushComplete(() => {
+      setReady(true);
+    });
+    return unsubscribe;
+  }, []);
+  return ready;
+}
+function useIdleGate(key, priority, callback) {
+  const [ready, setReady] = useState(false);
+  const callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  useEffect(() => {
+    const unregister = registerIdleTask(key, priority, async () => {
+      await callbackRef.current();
+      setReady(true);
+    });
+    return unregister;
+  }, [key, priority]);
+  return { ready };
+}
+function useIdleRegister() {
+  const unregisterRefs = useRef(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    const refs = unregisterRefs.current;
+    return () => {
+      refs.forEach((unregister) => unregister());
+      refs.clear();
+    };
+  }, []);
+  return useCallback(
+    (key, priority, callback) => {
+      unregisterRefs.current.get(key)?.();
+      const unregister = registerIdleTask(key, priority, callback);
+      unregisterRefs.current.set(key, unregister);
+    },
+    []
+  );
+}
+export {
+  getSchedulerState,
+  onFlushComplete,
+  registerIdleTask,
+  resetScheduler,
+  useIdleGate,
+  useIdleReady,
+  useIdleRegister,
+  useIdleTask,
+  whenPageIdle
+};
+//# sourceMappingURL=idle-scheduler.js.map

package/dist/idle-scheduler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/idle-scheduler/scheduler.ts","../src/idle-scheduler/hooks.ts"],"sourcesContent":["/**\n * IdleScheduler — a priority-aware deferred execution system for browser apps.\n *\n * Architecture:\n * - Process-wide singleton (NOT React context) — registrations cause zero re-renders\n * - Components register lightweight callbacks with priority 1-5\n * - The scheduler waits for the browser to be truly idle after full page render\n * - Then flushes all registered callbacks in priority order\n *\n * Priority levels:\n *   1 = Highest (first of the \"last things\") — e.g., analytics init, critical measurements\n *   2 = High — e.g., prefetching next-page data, service worker registration\n *   3 = Normal — e.g., lazy-loading non-critical UI, initializing 3rd party widgets\n *   4 = Low — e.g., telemetry, background sync setup\n *   5 = Lowest (absolute last) — e.g., prewarming caches, speculative prefetch\n *\n * Cross-browser idle detection chain:\n *   document.readyState === 'complete'\n *     → requestAnimationFrame (past next paint)\n *       → scheduler.postTask({ priority: 'background' })  [Chrome/Edge/Firefox 142+]\n *       → requestIdleCallback                              [Chrome/Firefox, NOT Safari]\n *       → MessageChannel postMessage                       [Universal — React's own trick]\n *\n * Ported from matrx-frontend `utils/idle-scheduler/idle-scheduler.ts`, with\n * TWO structural inversions, behavior otherwise verbatim:\n * - Scheduler state (queue, flush state, cleanups, listeners) lives on\n *   `globalThis` under `Symbol.for(\"ai-matrx.kit.idle-scheduler-state\")`\n *   instead of module-level variables. With the package built\n *   `splitting: false` in dual ESM/CJS format this module is duplicated into\n *   the root and `./idle-scheduler` bundles, and CJS/ESM each instantiate\n *   their own module graph — module-level state would silently split the\n *   flush pipeline from some registrants (the confirm-opener hazard). Never\n *   \"clean this up\" into module locals.\n * - The `window.__idleSched()` diagnostics probe installs on first API use\n *   instead of at module evaluation, keeping every entry point import-time\n *   inert (the package standard). The probe itself is unchanged.\n */\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\nexport type IdlePriority = 1 | 2 | 3 | 4 | 5;\n\nexport interface IdleRegistration {\n  /** Unique key for deduplication and cancellation */\n  key: string;\n  /** 1 = highest (first to run), 5 = lowest (last to run) */\n  priority: IdlePriority;\n  /** The deferred work */\n  callback: () => void | Promise<void>;\n}\n\nexport type UnregisterFn = () => void;\n\nexport type FlushState = \"idle\" | \"waiting\" | \"flushing\" | \"done\";\n\n/** Experimental Scheduler API (Chrome/Edge/Firefox 142+) — not yet in standard lib types. */\ninterface GlobalThisWithScheduler {\n  scheduler?: {\n    postTask: (callback: () => void, options?: { priority: string }) => Promise<void>;\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Singleton state — on globalThis so every bundle graph shares ONE pipeline\n// ---------------------------------------------------------------------------\n\ninterface SchedulerState {\n  queue: Map<string, IdleRegistration>;\n  flushState: FlushState;\n  cleanupFns: Array<() => void>;\n  /** Listeners that want to know when flush completes (for useIdleReady) */\n  flushListeners: Set<() => void>;\n}\n\nconst STATE_SLOT = Symbol.for(\"ai-matrx.kit.idle-scheduler-state\");\n\nfunction getState(): SchedulerState {\n  const holder = globalThis as Record<symbol, SchedulerState | undefined>;\n  let state = holder[STATE_SLOT];\n  if (!state) {\n    state = {\n      queue: new Map(),\n      flushState: \"idle\",\n      cleanupFns: [],\n      flushListeners: new Set(),\n    };\n    holder[STATE_SLOT] = state;\n\n    // Diagnostics probe: lets a console / agent read the live scheduler state\n    // (`window.__idleSched()`) — the wrapper-never-mounts class of bug is\n    // invisible without it.\n    if (typeof window !== \"undefined\") {\n      (window as unknown as { __idleSched?: () => unknown }).__idleSched =\n        getSchedulerState;\n    }\n  }\n  return state;\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/**\n * Register a callback to run after the page is fully idle.\n *\n * - If the scheduler hasn't flushed yet: queues the callback.\n * - If the scheduler already flushed: runs the callback immediately\n *   (through the same idle detection chain, so it still won't block).\n *\n * Returns an unregister function for cleanup.\n */\nexport function registerIdleTask(\n  key: string,\n  priority: IdlePriority,\n  callback: () => void | Promise<void>,\n): UnregisterFn {\n  const state = getState();\n\n  // If we already flushed, schedule this one immediately (still deferred)\n  if (state.flushState === \"done\") {\n    scheduleImmediate(callback);\n    return () => {};\n  }\n\n  state.queue.set(key, { key, priority, callback });\n\n  // Ensure the flush pipeline is started\n  if (state.flushState === \"idle\") {\n    startFlushPipeline(state);\n  }\n\n  return () => {\n    state.queue.delete(key);\n  };\n}\n\n/**\n * Subscribe to the flush-complete event.\n * Useful for components that just need a \"ready\" signal without registering work.\n */\nexport function onFlushComplete(listener: () => void): UnregisterFn {\n  const state = getState();\n\n  if (state.flushState === \"done\") {\n    // Already flushed — notify immediately (but async to avoid sync side effects)\n    queueMicrotask(listener);\n    return () => {};\n  }\n\n  state.flushListeners.add(listener);\n\n  // A \"tell me when idle\" subscriber needs the pipeline RUNNING. If only\n  // registerIdleTask started it, then on pages where nothing registered an\n  // idle task the flush would never run and every ready-gated mount would\n  // stay dormant forever. Subscribing must start the pipeline too.\n  if (state.flushState === \"idle\") {\n    startFlushPipeline(state);\n  }\n\n  return () => {\n    state.flushListeners.delete(listener);\n  };\n}\n\n/**\n * Resolve after the initial page-load idle flush, or earlier when aborted.\n * Non-React startup services use this instead of recreating the scheduler's\n * load → paint → browser-idle detection chain.\n *\n * @returns false when the caller aborted before idle; true otherwise.\n */\nexport function whenPageIdle(signal?: AbortSignal): Promise<boolean> {\n  if (signal?.aborted) return Promise.resolve(false);\n\n  return new Promise((resolve) => {\n    let settled = false;\n    let unsubscribe: UnregisterFn = () => {};\n\n    const finish = (ready: boolean) => {\n      if (settled) return;\n      settled = true;\n      unsubscribe();\n      signal?.removeEventListener(\"abort\", onAbort);\n      resolve(ready);\n    };\n    const onAbort = () => finish(false);\n\n    unsubscribe = onFlushComplete(() => finish(true));\n    signal?.addEventListener(\"abort\", onAbort, { once: true });\n  });\n}\n\n/**\n * Get current state — useful for debugging or conditional logic.\n */\nexport function getSchedulerState(): {\n  flushState: FlushState;\n  pendingCount: number;\n  pendingKeys: string[];\n} {\n  const state = getState();\n  return {\n    flushState: state.flushState,\n    pendingCount: state.queue.size,\n    pendingKeys: Array.from(state.queue.keys()),\n  };\n}\n\n/**\n * Reset the scheduler — primarily for testing or hot-reload scenarios.\n */\nexport function resetScheduler(): void {\n  const state = getState();\n  state.cleanupFns.forEach((fn) => fn());\n  state.cleanupFns = [];\n  state.queue.clear();\n  state.flushListeners.clear();\n  state.flushState = \"idle\";\n}\n\n// ---------------------------------------------------------------------------\n// Flush pipeline\n// ---------------------------------------------------------------------------\n\nfunction startFlushPipeline(state: SchedulerState): void {\n  if (typeof window === \"undefined\") return; // SSR guard\n\n  state.flushState = \"waiting\";\n\n  const waitForLoad = () => {\n    if (document.readyState === \"complete\") {\n      waitForPaint();\n    } else {\n      const onLoad = () => waitForPaint();\n      window.addEventListener(\"load\", onLoad, { once: true });\n      state.cleanupFns.push(() => window.removeEventListener(\"load\", onLoad));\n    }\n  };\n\n  const waitForPaint = () => {\n    // requestAnimationFrame NEVER fires while the tab is hidden (background\n    // tab, restored session, headless browser) — waiting on it alone hangs the\n    // whole pipeline forever in that state, so every ready-gated mount stays\n    // dormant. Paint alignment is an optimization, not a correctness\n    // requirement: race the rAF against a timeout so a hidden tab still\n    // flushes.\n    let advanced = false;\n    const advance = () => {\n      if (advanced) return;\n      advanced = true;\n      waitForIdle();\n    };\n    const rafId = requestAnimationFrame(advance);\n    const timeoutId = setTimeout(\n      advance,\n      document.visibilityState === \"hidden\" ? 250 : 1_500,\n    );\n    state.cleanupFns.push(() => {\n      cancelAnimationFrame(rafId);\n      clearTimeout(timeoutId);\n    });\n  };\n\n  const waitForIdle = () => {\n    // Tier 1: scheduler.postTask with background priority (Chrome/Edge/Firefox 142+)\n    const schedulerGlobal = (globalThis as GlobalThisWithScheduler).scheduler;\n    if (schedulerGlobal && \"postTask\" in schedulerGlobal) {\n      schedulerGlobal\n        .postTask(() => void flush(state), { priority: \"background\" })\n        .catch(() => {});\n      return;\n    }\n\n    // Tier 2: requestIdleCallback (Chrome, Firefox — NOT Safari stable)\n    if (\"requestIdleCallback\" in window) {\n      const idleId = requestIdleCallback(() => void flush(state));\n      state.cleanupFns.push(() => cancelIdleCallback(idleId));\n      return;\n    }\n\n    // Tier 3: MessageChannel — universal, including Safari + iOS Safari\n    // This is what React's scheduler uses internally.\n    const channel = new MessageChannel();\n    channel.port1.onmessage = () => void flush(state);\n    channel.port2.postMessage(undefined);\n  };\n\n  waitForLoad();\n}\n\nasync function flush(state: SchedulerState): Promise<void> {\n  if (state.flushState === \"done\" || state.flushState === \"flushing\") return;\n  state.flushState = \"flushing\";\n\n  // Sort by priority (1 first, 5 last), stable sort preserving insertion order within priority\n  const sorted = Array.from(state.queue.values()).sort(\n    (a, b) => a.priority - b.priority,\n  );\n\n  // Clear the queue before executing (so late registrations during flush\n  // are treated as \"post-flush\" and get scheduled immediately)\n  state.queue.clear();\n\n  for (const task of sorted) {\n    try {\n      await task.callback();\n    } catch (err) {\n      console.error(`[IdleScheduler] Task \"${task.key}\" failed:`, err);\n    }\n  }\n\n  state.flushState = \"done\";\n\n  // DEFECT FIX vs the original (see CHANGELOG 0.4.0): a task registered WHILE\n  // the flush loop was running (flushState === \"flushing\") landed back in the\n  // queue — which nothing ever drained again, so the task silently never ran.\n  // The comment above promises such registrations are \"treated as post-flush\n  // and get scheduled immediately\"; make that true.\n  if (state.queue.size > 0) {\n    const late = Array.from(state.queue.values()).sort(\n      (a, b) => a.priority - b.priority,\n    );\n    state.queue.clear();\n    for (const task of late) scheduleImmediate(task.callback);\n  }\n\n  // Notify all listeners\n  state.flushListeners.forEach((listener) => {\n    try {\n      listener();\n    } catch (err) {\n      console.error(\"[IdleScheduler] Flush listener failed:\", err);\n    }\n  });\n  state.flushListeners.clear();\n}\n\n// ---------------------------------------------------------------------------\n// Helpers\n// ---------------------------------------------------------------------------\n\n/** Schedule a single callback through the idle chain (for post-flush registrations) */\nfunction scheduleImmediate(callback: () => void | Promise<void>): void {\n  requestAnimationFrame(() => {\n    const schedulerGlobal = (globalThis as GlobalThisWithScheduler).scheduler;\n    if (schedulerGlobal && \"postTask\" in schedulerGlobal) {\n      schedulerGlobal\n        .postTask(() => void callback(), { priority: \"background\" })\n        .catch(() => {});\n      return;\n    }\n    if (\"requestIdleCallback\" in window) {\n      requestIdleCallback(() => void callback());\n      return;\n    }\n    const channel = new MessageChannel();\n    channel.port1.onmessage = () => void callback();\n    channel.port2.postMessage(undefined);\n  });\n}\n","/**\n * React hooks for the IdleScheduler.\n *\n * These are intentionally thin — they just wire up registration/cleanup\n * to React's lifecycle. No state, no context, no re-renders on registration.\n *\n * Three hooks for three use cases:\n *\n * 1. useIdleTask(key, priority, callback)\n *    → \"Run this callback when idle. I don't need to know when.\"\n *    → Fire-and-forget. Zero re-renders.\n *\n * 2. useIdleReady()\n *    → \"Just tell me when idle flush is done so I can wake up.\"\n *    → Returns a boolean. One re-render: false → true.\n *\n * 3. useIdleGate(key, priority, callback)\n *    → \"Run this callback when idle AND tell me when it's done.\"\n *    → Returns { ready: boolean }. Combines both patterns.\n *\n * Plus useIdleRegister() for imperative/conditional registration.\n *\n * Ported verbatim from matrx-frontend `utils/idle-scheduler/hooks.ts`.\n */\n\n\"use client\";\n\nimport { useEffect, useRef, useState, useCallback } from \"react\";\nimport {\n  registerIdleTask,\n  onFlushComplete,\n  type IdlePriority,\n} from \"./scheduler\";\n\n// ---------------------------------------------------------------------------\n// useIdleTask — fire-and-forget deferred work\n// ---------------------------------------------------------------------------\n\n/**\n * Register a callback to execute after page idle. Zero re-renders.\n *\n * @param key   Unique identifier (for deduplication/cancellation)\n * @param priority  1 (first of last) through 5 (absolute last)\n * @param callback  The deferred work\n *\n * @example\n * ```tsx\n * useIdleTask('analytics-init', 3, () => {\n *   initializeAnalytics();\n * });\n * ```\n */\nexport function useIdleTask(\n  key: string,\n  priority: IdlePriority,\n  callback: () => void | Promise<void>,\n): void {\n  const callbackRef = useRef(callback);\n  callbackRef.current = callback;\n\n  useEffect(() => {\n    const unregister = registerIdleTask(key, priority, () => {\n      return callbackRef.current();\n    });\n    return unregister;\n  }, [key, priority]);\n}\n\n// ---------------------------------------------------------------------------\n// useIdleReady — \"am I allowed to wake up yet?\"\n// ---------------------------------------------------------------------------\n\n/**\n * Returns `true` once the idle flush has completed.\n * Causes exactly one re-render (false → true). No work is registered.\n *\n * Use this when a component wants to stay dormant (show nothing, or a skeleton)\n * until the page is fully settled, then \"turn on.\"\n *\n * @example\n * ```tsx\n * function HeavyWidget() {\n *   const ready = useIdleReady();\n *   if (!ready) return null; // or a skeleton\n *   return <ExpensiveComponent />;\n * }\n * ```\n */\nexport function useIdleReady(): boolean {\n  const [ready, setReady] = useState(false);\n\n  useEffect(() => {\n    const unsubscribe = onFlushComplete(() => {\n      setReady(true);\n    });\n    return unsubscribe;\n  }, []);\n\n  return ready;\n}\n\n// ---------------------------------------------------------------------------\n// useIdleGate — register work AND get a ready signal\n// ---------------------------------------------------------------------------\n\n/**\n * Register deferred work and get a `ready` signal when it completes.\n *\n * This is the \"full package\" — your component stays dormant, the scheduler\n * runs your callback at the right time, and then you get notified to\n * update your UI.\n *\n * @example\n * ```tsx\n * function PrefetchedSection() {\n *   const { ready } = useIdleGate('prefetch-recommendations', 2, async () => {\n *     await prefetchRecommendations();\n *   });\n *\n *   if (!ready) return <Skeleton />;\n *   return <Recommendations />;\n * }\n * ```\n */\nexport function useIdleGate(\n  key: string,\n  priority: IdlePriority,\n  callback: () => void | Promise<void>,\n): { ready: boolean } {\n  const [ready, setReady] = useState(false);\n  const callbackRef = useRef(callback);\n  callbackRef.current = callback;\n\n  useEffect(() => {\n    const unregister = registerIdleTask(key, priority, async () => {\n      await callbackRef.current();\n      setReady(true);\n    });\n    return unregister;\n  }, [key, priority]);\n\n  return { ready };\n}\n\n// ---------------------------------------------------------------------------\n// useIdleRegister — imperative registration (for dynamic/conditional work)\n// ---------------------------------------------------------------------------\n\n/**\n * Returns a `register` function you can call imperatively.\n * Useful when the deferred work depends on runtime conditions.\n *\n * @example\n * ```tsx\n * function SearchResults({ query }) {\n *   const scheduleIdle = useIdleRegister();\n *\n *   useEffect(() => {\n *     if (query) {\n *       scheduleIdle(`prefetch-${query}`, 4, () => {\n *         prefetchRelatedResults(query);\n *       });\n *     }\n *   }, [query, scheduleIdle]);\n * }\n * ```\n */\nexport function useIdleRegister(): (\n  key: string,\n  priority: IdlePriority,\n  callback: () => void | Promise<void>,\n) => void {\n  const unregisterRefs = useRef<Map<string, () => void>>(new Map());\n\n  // Cleanup all registrations on unmount\n  useEffect(() => {\n    const refs = unregisterRefs.current;\n    return () => {\n      refs.forEach((unregister) => unregister());\n      refs.clear();\n    };\n  }, []);\n\n  return useCallback(\n    (\n      key: string,\n      priority: IdlePriority,\n      callback: () => void | Promise<void>,\n    ) => {\n      // Cancel previous registration with same key\n      unregisterRefs.current.get(key)?.();\n\n      const unregister = registerIdleTask(key, priority, callback);\n      unregisterRefs.current.set(key, unregister);\n    },\n    [],\n  );\n}\n"],"mappings":"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","names":[]}