@almadar/ui 1.0.0

package/dist/providers/index.js

@@ -0,0 +1,1111 @@
+import { createContext, useRef, useCallback, useMemo, useEffect, useState, useContext } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var BUILT_IN_THEMES = [
+  {
+    name: "wireframe",
+    displayName: "Wireframe",
+    hasLightMode: true,
+    hasDarkMode: true
+  },
+  {
+    name: "minimalist",
+    displayName: "Minimalist",
+    hasLightMode: true,
+    hasDarkMode: true
+  },
+  {
+    name: "almadar",
+    displayName: "Almadar",
+    hasLightMode: true,
+    hasDarkMode: true
+  }
+];
+var ThemeContext = createContext(void 0);
+var THEME_STORAGE_KEY = "theme";
+var MODE_STORAGE_KEY = "theme-mode";
+function getSystemMode() {
+  if (typeof window === "undefined") return "light";
+  return window.matchMedia("(prefers-color-scheme: dark)").matches ? "dark" : "light";
+}
+function resolveMode(mode) {
+  if (mode === "system") {
+    return getSystemMode();
+  }
+  return mode;
+}
+var ThemeProvider = ({
+  children,
+  themes = [],
+  defaultTheme = "wireframe",
+  defaultMode = "system"
+}) => {
+  const availableThemes = useMemo(() => {
+    const themeMap = /* @__PURE__ */ new Map();
+    BUILT_IN_THEMES.forEach((t) => themeMap.set(t.name, t));
+    themes.forEach((t) => themeMap.set(t.name, t));
+    return Array.from(themeMap.values());
+  }, [themes]);
+  const [theme, setThemeState] = useState(() => {
+    if (typeof window === "undefined") return defaultTheme;
+    const stored = localStorage.getItem(THEME_STORAGE_KEY);
+    const validThemes = [
+      ...BUILT_IN_THEMES.map((t) => t.name),
+      ...themes.map((t) => t.name)
+    ];
+    if (stored && validThemes.includes(stored)) {
+      return stored;
+    }
+    return defaultTheme;
+  });
+  const [mode, setModeState] = useState(() => {
+    if (typeof window === "undefined") return defaultMode;
+    const stored = localStorage.getItem(MODE_STORAGE_KEY);
+    if (stored === "light" || stored === "dark" || stored === "system") {
+      return stored;
+    }
+    return defaultMode;
+  });
+  const [resolvedMode, setResolvedMode] = useState(
+    () => resolveMode(mode)
+  );
+  const appliedTheme = useMemo(
+    () => `${theme}-${resolvedMode}`,
+    [theme, resolvedMode]
+  );
+  useEffect(() => {
+    const updateResolved = () => {
+      setResolvedMode(resolveMode(mode));
+    };
+    updateResolved();
+    if (mode === "system") {
+      const mediaQuery = window.matchMedia("(prefers-color-scheme: dark)");
+      const handleChange = () => updateResolved();
+      mediaQuery.addEventListener("change", handleChange);
+      return () => mediaQuery.removeEventListener("change", handleChange);
+    }
+    return void 0;
+  }, [mode]);
+  useEffect(() => {
+    const root = document.documentElement;
+    root.setAttribute("data-theme", appliedTheme);
+    root.classList.remove("light", "dark");
+    root.classList.add(resolvedMode);
+  }, [appliedTheme, resolvedMode]);
+  const setTheme = useCallback(
+    (newTheme) => {
+      const validTheme = availableThemes.find((t) => t.name === newTheme);
+      if (validTheme) {
+        setThemeState(newTheme);
+        if (typeof window !== "undefined") {
+          localStorage.setItem(THEME_STORAGE_KEY, newTheme);
+        }
+      } else {
+        console.warn(
+          `Theme "${newTheme}" not found. Available: ${availableThemes.map((t) => t.name).join(", ")}`
+        );
+      }
+    },
+    [availableThemes]
+  );
+  const setMode = useCallback((newMode) => {
+    setModeState(newMode);
+    if (typeof window !== "undefined") {
+      localStorage.setItem(MODE_STORAGE_KEY, newMode);
+    }
+  }, []);
+  const toggleMode = useCallback(() => {
+    const newMode = resolvedMode === "dark" ? "light" : "dark";
+    setMode(newMode);
+  }, [resolvedMode, setMode]);
+  const contextValue = useMemo(
+    () => ({
+      theme,
+      mode,
+      resolvedMode,
+      setTheme,
+      setMode,
+      toggleMode,
+      availableThemes,
+      appliedTheme
+    }),
+    [
+      theme,
+      mode,
+      resolvedMode,
+      setTheme,
+      setMode,
+      toggleMode,
+      availableThemes,
+      appliedTheme
+    ]
+  );
+  return /* @__PURE__ */ jsx(ThemeContext.Provider, { value: contextValue, children });
+};
+var DEFAULT_SLOTS = {
+  main: null,
+  sidebar: null,
+  modal: null,
+  drawer: null,
+  overlay: null,
+  center: null,
+  toast: null,
+  "hud-top": null,
+  "hud-bottom": null,
+  floating: null
+};
+var idCounter = 0;
+function generateId() {
+  return `slot-content-${++idCounter}-${Date.now()}`;
+}
+function useUISlotManager() {
+  const [slots, setSlots] = useState(DEFAULT_SLOTS);
+  const subscribersRef = useRef(/* @__PURE__ */ new Set());
+  const timersRef = useRef(/* @__PURE__ */ new Map());
+  useEffect(() => {
+    return () => {
+      timersRef.current.forEach((timer) => clearTimeout(timer));
+      timersRef.current.clear();
+    };
+  }, []);
+  const notifySubscribers = useCallback((slot, content) => {
+    subscribersRef.current.forEach((callback) => {
+      try {
+        callback(slot, content);
+      } catch (error) {
+        console.error("[UISlots] Subscriber error:", error);
+      }
+    });
+  }, []);
+  const render = useCallback((config) => {
+    const id = generateId();
+    const content = {
+      id,
+      pattern: config.pattern,
+      props: config.props ?? {},
+      priority: config.priority ?? 0,
+      animation: config.animation ?? "fade",
+      onDismiss: config.onDismiss,
+      sourceTrait: config.sourceTrait
+    };
+    if (config.autoDismissMs && config.autoDismissMs > 0) {
+      content.autoDismissAt = Date.now() + config.autoDismissMs;
+      const timer = setTimeout(() => {
+        setSlots((prev) => {
+          if (prev[config.target]?.id === id) {
+            content.onDismiss?.();
+            notifySubscribers(config.target, null);
+            return { ...prev, [config.target]: null };
+          }
+          return prev;
+        });
+        timersRef.current.delete(id);
+      }, config.autoDismissMs);
+      timersRef.current.set(id, timer);
+    }
+    setSlots((prev) => {
+      const existing = prev[config.target];
+      if (existing && existing.priority > content.priority) {
+        console.warn(
+          `[UISlots] Slot "${config.target}" already has higher priority content (${existing.priority} > ${content.priority})`
+        );
+        return prev;
+      }
+      notifySubscribers(config.target, content);
+      return { ...prev, [config.target]: content };
+    });
+    return id;
+  }, [notifySubscribers]);
+  const clear = useCallback((slot) => {
+    setSlots((prev) => {
+      const content = prev[slot];
+      if (content) {
+        const timer = timersRef.current.get(content.id);
+        if (timer) {
+          clearTimeout(timer);
+          timersRef.current.delete(content.id);
+        }
+        content.onDismiss?.();
+        notifySubscribers(slot, null);
+      }
+      return { ...prev, [slot]: null };
+    });
+  }, [notifySubscribers]);
+  const clearById = useCallback((id) => {
+    setSlots((prev) => {
+      const entry = Object.entries(prev).find(([, content]) => content?.id === id);
+      if (entry) {
+        const [slot, content] = entry;
+        const timer = timersRef.current.get(id);
+        if (timer) {
+          clearTimeout(timer);
+          timersRef.current.delete(id);
+        }
+        content.onDismiss?.();
+        notifySubscribers(slot, null);
+        return { ...prev, [slot]: null };
+      }
+      return prev;
+    });
+  }, [notifySubscribers]);
+  const clearAll = useCallback(() => {
+    timersRef.current.forEach((timer) => clearTimeout(timer));
+    timersRef.current.clear();
+    setSlots((prev) => {
+      Object.entries(prev).forEach(([slot, content]) => {
+        if (content) {
+          content.onDismiss?.();
+          notifySubscribers(slot, null);
+        }
+      });
+      return DEFAULT_SLOTS;
+    });
+  }, [notifySubscribers]);
+  const subscribe = useCallback((callback) => {
+    subscribersRef.current.add(callback);
+    return () => {
+      subscribersRef.current.delete(callback);
+    };
+  }, []);
+  const hasContent = useCallback((slot) => {
+    return slots[slot] !== null;
+  }, [slots]);
+  const getContent = useCallback((slot) => {
+    return slots[slot];
+  }, [slots]);
+  return {
+    slots,
+    render,
+    clear,
+    clearById,
+    clearAll,
+    subscribe,
+    hasContent,
+    getContent
+  };
+}
+var UISlotContext = createContext(null);
+function UISlotProvider({ children }) {
+  const slotManager = useUISlotManager();
+  const contextValue = useMemo(() => slotManager, [slotManager]);
+  return /* @__PURE__ */ jsx(UISlotContext.Provider, { value: contextValue, children });
+}
+var globalEventBus = null;
+function setGlobalEventBus(bus) {
+  globalEventBus = bus;
+}
+var fallbackListeners = /* @__PURE__ */ new Map();
+var fallbackEventBus = {
+  emit: (type, payload) => {
+    const event = {
+      type,
+      payload,
+      timestamp: Date.now()
+    };
+    const handlers = fallbackListeners.get(type);
+    if (handlers) {
+      handlers.forEach((handler) => {
+        try {
+          handler(event);
+        } catch (error) {
+          console.error(`[EventBus] Error in listener for '${type}':`, error);
+        }
+      });
+    }
+  },
+  on: (type, listener) => {
+    if (!fallbackListeners.has(type)) {
+      fallbackListeners.set(type, /* @__PURE__ */ new Set());
+    }
+    fallbackListeners.get(type).add(listener);
+    return () => {
+      const handlers = fallbackListeners.get(type);
+      if (handlers) {
+        handlers.delete(listener);
+        if (handlers.size === 0) {
+          fallbackListeners.delete(type);
+        }
+      }
+    };
+  },
+  once: (type, listener) => {
+    const wrappedListener = (event) => {
+      fallbackListeners.get(type)?.delete(wrappedListener);
+      listener(event);
+    };
+    return fallbackEventBus.on(type, wrappedListener);
+  },
+  hasListeners: (type) => {
+    const handlers = fallbackListeners.get(type);
+    return handlers !== void 0 && handlers.size > 0;
+  }
+};
+function useEventBus() {
+  const context = useContext(EventBusContext);
+  return context ?? globalEventBus ?? fallbackEventBus;
+}
+var EventBusContext = createContext(null);
+function EventBusProvider({ children, debug = false }) {
+  const listenersRef = useRef(/* @__PURE__ */ new Map());
+  const deprecationWarningShown = useRef(false);
+  const getSelectedEntity = useCallback(() => {
+    if (!deprecationWarningShown.current) {
+      console.warn(
+        "[EventBus] getSelectedEntity is deprecated. Use SelectionProvider and useSelection hook instead. See SelectionProvider.tsx for migration guide."
+      );
+      deprecationWarningShown.current = true;
+    }
+    return null;
+  }, []);
+  const clearSelectedEntity = useCallback(() => {
+    if (!deprecationWarningShown.current) {
+      console.warn(
+        "[EventBus] clearSelectedEntity is deprecated. Use SelectionProvider and useSelection hook instead. See SelectionProvider.tsx for migration guide."
+      );
+      deprecationWarningShown.current = true;
+    }
+  }, []);
+  const emit = useCallback((type, payload) => {
+    const event = {
+      type,
+      payload,
+      timestamp: Date.now()
+    };
+    const listeners = listenersRef.current.get(type);
+    const listenerCount = listeners?.size ?? 0;
+    if (debug) {
+      if (listenerCount > 0) {
+        console.log(`[EventBus] Emit: ${type} \u2192 ${listenerCount} listener(s)`, payload);
+      } else {
+        console.warn(`[EventBus] Emit: ${type} (NO LISTENERS - event may be lost!)`, payload);
+      }
+    }
+    if (listeners) {
+      const listenersCopy = Array.from(listeners);
+      for (const listener of listenersCopy) {
+        try {
+          listener(event);
+        } catch (error) {
+          console.error(`[EventBus] Error in listener for '${type}':`, error);
+        }
+      }
+    }
+  }, [debug]);
+  const on = useCallback((type, listener) => {
+    if (!listenersRef.current.has(type)) {
+      listenersRef.current.set(type, /* @__PURE__ */ new Set());
+    }
+    const listeners = listenersRef.current.get(type);
+    listeners.add(listener);
+    if (debug) {
+      console.log(`[EventBus] Subscribed to '${type}', total: ${listeners.size}`);
+    }
+    return () => {
+      listeners.delete(listener);
+      if (debug) {
+        console.log(`[EventBus] Unsubscribed from '${type}', remaining: ${listeners.size}`);
+      }
+      if (listeners.size === 0) {
+        listenersRef.current.delete(type);
+      }
+    };
+  }, [debug]);
+  const once = useCallback((type, listener) => {
+    const wrappedListener = (event) => {
+      listenersRef.current.get(type)?.delete(wrappedListener);
+      listener(event);
+    };
+    return on(type, wrappedListener);
+  }, [on]);
+  const hasListeners = useCallback((type) => {
+    const listeners = listenersRef.current.get(type);
+    return listeners !== void 0 && listeners.size > 0;
+  }, []);
+  const contextValue = useMemo(
+    () => ({
+      emit,
+      on,
+      once,
+      hasListeners,
+      getSelectedEntity,
+      clearSelectedEntity
+    }),
+    [emit, on, once, hasListeners, getSelectedEntity, clearSelectedEntity]
+  );
+  useEffect(() => {
+    setGlobalEventBus(contextValue);
+    return () => {
+      setGlobalEventBus(null);
+    };
+  }, [contextValue]);
+  return /* @__PURE__ */ jsx(EventBusContext.Provider, { value: contextValue, children });
+}
+var SelectionContext = createContext(null);
+var defaultCompareEntities = (a, b) => {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  if (typeof a === "object" && typeof b === "object") {
+    const aId = a.id;
+    const bId = b.id;
+    return aId !== void 0 && aId === bId;
+  }
+  return false;
+};
+function SelectionProvider({
+  children,
+  debug = false,
+  compareEntities = defaultCompareEntities
+}) {
+  const eventBus = useEventBus();
+  const [selected, setSelectedState] = useState(null);
+  const setSelected = useCallback(
+    (entity) => {
+      setSelectedState(entity);
+      if (debug) {
+        console.log("[SelectionProvider] Selection set:", entity);
+      }
+    },
+    [debug]
+  );
+  const clearSelection = useCallback(() => {
+    setSelectedState(null);
+    if (debug) {
+      console.log("[SelectionProvider] Selection cleared");
+    }
+  }, [debug]);
+  const isSelected = useCallback(
+    (entity) => {
+      return compareEntities(selected, entity);
+    },
+    [selected, compareEntities]
+  );
+  useEffect(() => {
+    const handleSelect = (event) => {
+      const row = event.payload?.row;
+      if (row) {
+        setSelected(row);
+        if (debug) {
+          console.log(`[SelectionProvider] ${event.type} received:`, row);
+        }
+      }
+    };
+    const handleDeselect = (event) => {
+      clearSelection();
+      if (debug) {
+        console.log(`[SelectionProvider] ${event.type} received - clearing selection`);
+      }
+    };
+    const unsubView = eventBus.on("UI:VIEW", handleSelect);
+    const unsubSelect = eventBus.on("UI:SELECT", handleSelect);
+    const unsubClose = eventBus.on("UI:CLOSE", handleDeselect);
+    const unsubDeselect = eventBus.on("UI:DESELECT", handleDeselect);
+    const unsubCancel = eventBus.on("UI:CANCEL", handleDeselect);
+    return () => {
+      unsubView();
+      unsubSelect();
+      unsubClose();
+      unsubDeselect();
+      unsubCancel();
+    };
+  }, [eventBus, setSelected, clearSelection, debug]);
+  const contextValue = {
+    selected,
+    setSelected,
+    clearSelection,
+    isSelected
+  };
+  return /* @__PURE__ */ jsx(SelectionContext.Provider, { value: contextValue, children });
+}
+function useSelection() {
+  const context = useContext(SelectionContext);
+  if (!context) {
+    throw new Error("useSelection must be used within a SelectionProvider");
+  }
+  return context;
+}
+function useSelectionOptional() {
+  const context = useContext(SelectionContext);
+  return context;
+}
+var FetchedDataContext = createContext(null);
+function FetchedDataProvider({
+  initialData,
+  children
+}) {
+  const [state, setState] = useState(() => ({
+    data: initialData || {},
+    fetchedAt: {},
+    loading: false,
+    error: null
+  }));
+  const getData = useCallback(
+    (entityName) => {
+      return state.data[entityName] || [];
+    },
+    [state.data]
+  );
+  const getById = useCallback(
+    (entityName, id) => {
+      const records = state.data[entityName];
+      return records?.find((r) => r.id === id);
+    },
+    [state.data]
+  );
+  const hasData = useCallback(
+    (entityName) => {
+      return entityName in state.data && state.data[entityName].length > 0;
+    },
+    [state.data]
+  );
+  const getFetchedAt = useCallback(
+    (entityName) => {
+      return state.fetchedAt[entityName];
+    },
+    [state.fetchedAt]
+  );
+  const setData = useCallback((data) => {
+    const now = Date.now();
+    setState((prev) => ({
+      ...prev,
+      data: {
+        ...prev.data,
+        ...data
+      },
+      fetchedAt: {
+        ...prev.fetchedAt,
+        ...Object.keys(data).reduce(
+          (acc, key) => ({ ...acc, [key]: now }),
+          {}
+        )
+      },
+      loading: false,
+      error: null
+    }));
+  }, []);
+  const clearData = useCallback(() => {
+    setState((prev) => ({
+      ...prev,
+      data: {},
+      fetchedAt: {}
+    }));
+  }, []);
+  const clearEntity = useCallback((entityName) => {
+    setState((prev) => {
+      const newData = { ...prev.data };
+      const newFetchedAt = { ...prev.fetchedAt };
+      delete newData[entityName];
+      delete newFetchedAt[entityName];
+      return {
+        ...prev,
+        data: newData,
+        fetchedAt: newFetchedAt
+      };
+    });
+  }, []);
+  const setLoading = useCallback((loading) => {
+    setState((prev) => ({ ...prev, loading }));
+  }, []);
+  const setError = useCallback((error) => {
+    setState((prev) => ({ ...prev, error, loading: false }));
+  }, []);
+  const contextValue = useMemo(
+    () => ({
+      getData,
+      getById,
+      hasData,
+      getFetchedAt,
+      setData,
+      clearData,
+      clearEntity,
+      loading: state.loading,
+      setLoading,
+      error: state.error,
+      setError
+    }),
+    [
+      getData,
+      getById,
+      hasData,
+      getFetchedAt,
+      setData,
+      clearData,
+      clearEntity,
+      state.loading,
+      setLoading,
+      state.error,
+      setError
+    ]
+  );
+  return /* @__PURE__ */ jsx(FetchedDataContext.Provider, { value: contextValue, children });
+}
+function useFetchedDataContext() {
+  return useContext(FetchedDataContext);
+}
+function useFetchedData() {
+  const context = useContext(FetchedDataContext);
+  if (!context) {
+    return {
+      getData: () => [],
+      getById: () => void 0,
+      hasData: () => false,
+      getFetchedAt: () => void 0,
+      setData: () => {
+      },
+      clearData: () => {
+      },
+      clearEntity: () => {
+      },
+      loading: false,
+      setLoading: () => {
+      },
+      error: null,
+      setError: () => {
+      }
+    };
+  }
+  return context;
+}
+function useFetchedEntity(entityName) {
+  const context = useFetchedData();
+  return {
+    /** All fetched records for this entity */
+    records: context.getData(entityName),
+    /** Get a record by ID */
+    getById: (id) => context.getById(entityName, id),
+    /** Whether data has been fetched for this entity */
+    hasData: context.hasData(entityName),
+    /** When data was last fetched */
+    fetchedAt: context.getFetchedAt(entityName),
+    /** Whether data is loading */
+    loading: context.loading,
+    /** Current error */
+    error: context.error
+  };
+}
+function OrbitalProvider({
+  children,
+  themes,
+  defaultTheme = "wireframe",
+  defaultMode = "system",
+  debug = false,
+  initialData
+}) {
+  return /* @__PURE__ */ jsx(
+    ThemeProvider,
+    {
+      themes,
+      defaultTheme,
+      defaultMode,
+      children: /* @__PURE__ */ jsx(FetchedDataProvider, { initialData, children: /* @__PURE__ */ jsx(EventBusProvider, { debug, children: /* @__PURE__ */ jsx(UISlotProvider, { children: /* @__PURE__ */ jsx(SelectionProvider, { debug, children }) }) }) })
+    }
+  );
+}
+OrbitalProvider.displayName = "OrbitalProvider";
+
+// renderer/client-effect-executor.ts
+function executeClientEffects(effects, config) {
+  if (!effects || effects.length === 0) {
+    return;
+  }
+  for (const effect of effects) {
+    try {
+      executeEffect(effect, config);
+    } catch (error) {
+      console.error(
+        `[ClientEffectExecutor] Error executing effect:`,
+        effect,
+        error
+      );
+    }
+  }
+  config.onComplete?.();
+}
+function executeEffect(effect, config) {
+  const [effectType, ...args] = effect;
+  switch (effectType) {
+    case "render-ui": {
+      const [slot, patternConfig] = args;
+      executeRenderUI(slot, patternConfig, config);
+      break;
+    }
+    case "navigate": {
+      const [path, params] = args;
+      executeNavigate(path, params, config);
+      break;
+    }
+    case "notify": {
+      const [message, options] = args;
+      executeNotify(message, options, config);
+      break;
+    }
+    case "emit": {
+      const [event, payload] = args;
+      executeEmit(event, payload, config);
+      break;
+    }
+    default:
+      console.warn(`[ClientEffectExecutor] Unknown effect type: ${effectType}`);
+  }
+}
+function executeRenderUI(slot, patternConfig, config) {
+  config.renderToSlot(slot, patternConfig);
+}
+function executeNavigate(path, params, config) {
+  config.navigate(path, params);
+}
+function executeNotify(message, options, config) {
+  config.notify(message, options);
+}
+function executeEmit(event, payload, config) {
+  config.eventBus.emit(event, payload);
+}
+var effectIdCounter = 0;
+function generateEffectId() {
+  return `offline-effect-${++effectIdCounter}-${Date.now()}`;
+}
+var OfflineExecutor = class {
+  constructor(config) {
+    __publicField(this, "config");
+    __publicField(this, "state");
+    __publicField(this, "storage");
+    /**
+     * Handle going online
+     */
+    __publicField(this, "handleOnline", () => {
+      this.state.isOffline = false;
+    });
+    /**
+     * Handle going offline
+     */
+    __publicField(this, "handleOffline", () => {
+      this.state.isOffline = true;
+    });
+    this.config = {
+      enableSyncQueue: true,
+      maxQueueSize: 100,
+      ...config
+    };
+    this.state = {
+      isOffline: !this.checkOnline(),
+      syncQueue: [],
+      localEffectsProcessed: 0,
+      effectsSynced: 0
+    };
+    this.storage = typeof localStorage !== "undefined" ? localStorage : null;
+    this.loadSyncQueue();
+    if (typeof window !== "undefined") {
+      window.addEventListener("online", this.handleOnline);
+      window.addEventListener("offline", this.handleOffline);
+    }
+  }
+  /**
+   * Check if we're online (browser API)
+   */
+  checkOnline() {
+    return typeof navigator !== "undefined" ? navigator.onLine : true;
+  }
+  /**
+   * Load sync queue from localStorage
+   */
+  loadSyncQueue() {
+    if (!this.storage) return;
+    try {
+      const stored = this.storage.getItem("orbital-offline-queue");
+      if (stored) {
+        this.state.syncQueue = JSON.parse(stored);
+      }
+    } catch (error) {
+      console.warn("[OfflineExecutor] Failed to load sync queue:", error);
+    }
+  }
+  /**
+   * Save sync queue to localStorage
+   */
+  saveSyncQueue() {
+    if (!this.storage) return;
+    try {
+      this.storage.setItem("orbital-offline-queue", JSON.stringify(this.state.syncQueue));
+    } catch (error) {
+      console.warn("[OfflineExecutor] Failed to save sync queue:", error);
+    }
+  }
+  /**
+   * Add an effect to the sync queue
+   */
+  queueForSync(type, payload) {
+    if (!this.config.enableSyncQueue) return;
+    const effect = {
+      id: generateEffectId(),
+      timestamp: Date.now(),
+      type,
+      payload,
+      retries: 0,
+      maxRetries: 3
+    };
+    this.state.syncQueue.push(effect);
+    if (this.state.syncQueue.length > (this.config.maxQueueSize ?? 100)) {
+      this.state.syncQueue.shift();
+    }
+    this.saveSyncQueue();
+    this.config.onEffectQueued?.(effect);
+    this.config.onQueueChange?.(this.state.syncQueue);
+  }
+  /**
+   * Execute client effects immediately.
+   */
+  executeClientEffects(effects) {
+    if (effects.length === 0) return;
+    executeClientEffects(effects, this.config);
+    this.state.localEffectsProcessed += effects.length;
+  }
+  /**
+   * Process an event in offline mode.
+   *
+   * Returns a simulated EventResponse with mock data.
+   * Client effects are executed immediately.
+   * Server effects are queued for sync.
+   */
+  processEventOffline(event, payload, effects) {
+    const clientEffects = [];
+    const fetchedData = {};
+    if (effects) {
+      for (const effect of effects) {
+        if (!Array.isArray(effect) || effect.length < 1) continue;
+        const [type, ...args] = effect;
+        switch (type) {
+          // Client effects - execute immediately
+          case "render-ui":
+          case "navigate":
+          case "notify":
+          case "emit":
+            clientEffects.push(effect);
+            break;
+          // Fetch effect - use mock data
+          case "fetch": {
+            const [entityName, _query] = args;
+            if (typeof entityName === "string" && this.config.mockDataProvider) {
+              fetchedData[entityName] = this.config.mockDataProvider(entityName);
+            }
+            break;
+          }
+          // Server effects - queue for sync
+          case "persist":
+          case "call-service":
+          case "spawn":
+          case "despawn":
+            this.queueForSync(type, { args, event, payload });
+            break;
+          default:
+            console.warn(`[OfflineExecutor] Unknown effect type: ${type}`);
+        }
+      }
+    }
+    if (clientEffects.length > 0) {
+      this.executeClientEffects(clientEffects);
+    }
+    return {
+      success: true,
+      data: Object.keys(fetchedData).length > 0 ? fetchedData : void 0,
+      clientEffects: clientEffects.length > 0 ? clientEffects : void 0
+    };
+  }
+  /**
+   * Sync pending effects to server.
+   *
+   * @param serverUrl - Base URL for the orbital server
+   * @param authToken - Optional auth token for requests
+   * @returns Number of successfully synced effects
+   */
+  async syncPendingEffects(serverUrl, authToken) {
+    if (this.state.syncQueue.length === 0) {
+      return 0;
+    }
+    this.state.lastSyncAttempt = Date.now();
+    let syncedCount = 0;
+    const failedEffects = [];
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (authToken) {
+      headers["Authorization"] = `Bearer ${authToken}`;
+    }
+    for (const effect of this.state.syncQueue) {
+      try {
+        const response = await fetch(`${serverUrl}/sync-effect`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            type: effect.type,
+            payload: effect.payload,
+            offlineId: effect.id,
+            offlineTimestamp: effect.timestamp
+          })
+        });
+        if (response.ok) {
+          syncedCount++;
+        } else {
+          effect.retries++;
+          if (effect.retries < effect.maxRetries) {
+            failedEffects.push(effect);
+          }
+        }
+      } catch (error) {
+        effect.retries++;
+        if (effect.retries < effect.maxRetries) {
+          failedEffects.push(effect);
+        }
+      }
+    }
+    this.state.syncQueue = failedEffects;
+    this.state.effectsSynced += syncedCount;
+    if (syncedCount > 0) {
+      this.state.lastSuccessfulSync = Date.now();
+    }
+    this.saveSyncQueue();
+    this.config.onQueueChange?.(this.state.syncQueue);
+    return syncedCount;
+  }
+  /**
+   * Get current executor state
+   */
+  getState() {
+    return { ...this.state };
+  }
+  /**
+   * Get number of pending effects
+   */
+  getPendingCount() {
+    return this.state.syncQueue.length;
+  }
+  /**
+   * Clear the sync queue
+   */
+  clearQueue() {
+    this.state.syncQueue = [];
+    this.saveSyncQueue();
+    this.config.onQueueChange?.(this.state.syncQueue);
+  }
+  /**
+   * Dispose the executor and clean up listeners
+   */
+  dispose() {
+    if (typeof window !== "undefined") {
+      window.removeEventListener("online", this.handleOnline);
+      window.removeEventListener("offline", this.handleOffline);
+    }
+  }
+};
+function useOfflineExecutor(options) {
+  const executorRef = useRef(null);
+  const [state, setState] = useState({
+    isOffline: false,
+    syncQueue: [],
+    localEffectsProcessed: 0,
+    effectsSynced: 0
+  });
+  useEffect(() => {
+    const executor = new OfflineExecutor({
+      ...options,
+      onQueueChange: (queue) => {
+        setState(executor.getState());
+        options.onQueueChange?.(queue);
+      }
+    });
+    executorRef.current = executor;
+    setState(executor.getState());
+    return () => {
+      executor.dispose();
+      executorRef.current = null;
+    };
+  }, []);
+  useEffect(() => {
+    if (!options.autoSync || !options.serverUrl) return;
+    const handleOnline = async () => {
+      if (executorRef.current) {
+        await executorRef.current.syncPendingEffects(
+          options.serverUrl,
+          options.authToken
+        );
+        setState(executorRef.current.getState());
+      }
+    };
+    window.addEventListener("online", handleOnline);
+    return () => window.removeEventListener("online", handleOnline);
+  }, [options.autoSync, options.serverUrl, options.authToken]);
+  const executeEffects = useCallback((effects) => {
+    executorRef.current?.executeClientEffects(effects);
+    if (executorRef.current) {
+      setState(executorRef.current.getState());
+    }
+  }, []);
+  const processEventOffline = useCallback(
+    (event, payload, effects) => {
+      const result = executorRef.current?.processEventOffline(event, payload, effects);
+      if (executorRef.current) {
+        setState(executorRef.current.getState());
+      }
+      return result ?? { success: false, error: "Executor not initialized" };
+    },
+    []
+  );
+  const sync = useCallback(async () => {
+    if (!executorRef.current || !options.serverUrl) return 0;
+    const count = await executorRef.current.syncPendingEffects(
+      options.serverUrl,
+      options.authToken
+    );
+    setState(executorRef.current.getState());
+    return count;
+  }, [options.serverUrl, options.authToken]);
+  const clearQueue = useCallback(() => {
+    executorRef.current?.clearQueue();
+    if (executorRef.current) {
+      setState(executorRef.current.getState());
+    }
+  }, []);
+  return {
+    state,
+    isOffline: state.isOffline,
+    pendingCount: state.syncQueue.length,
+    executeClientEffects: executeEffects,
+    processEventOffline,
+    sync,
+    clearQueue
+  };
+}
+var OfflineModeContext = createContext(null);
+function OfflineModeProvider({
+  children,
+  ...executorOptions
+}) {
+  const [forceOffline, setForceOffline] = useState(false);
+  const executor = useOfflineExecutor(executorOptions);
+  const effectivelyOffline = executor.isOffline || forceOffline;
+  const contextValue = useMemo(
+    () => ({
+      ...executor,
+      forceOffline,
+      setForceOffline,
+      effectivelyOffline
+    }),
+    [executor, forceOffline, effectivelyOffline]
+  );
+  return /* @__PURE__ */ jsx(OfflineModeContext.Provider, { value: contextValue, children });
+}
+function useOfflineMode() {
+  const context = useContext(OfflineModeContext);
+  if (!context) {
+    throw new Error("useOfflineMode must be used within OfflineModeProvider");
+  }
+  return context;
+}
+function useOptionalOfflineMode() {
+  return useContext(OfflineModeContext);
+}
+
+export { EventBusContext, EventBusProvider, FetchedDataContext, FetchedDataProvider, OfflineModeProvider, OrbitalProvider, SelectionContext, SelectionProvider, useFetchedData, useFetchedDataContext, useFetchedEntity, useOfflineMode, useOptionalOfflineMode, useSelection, useSelectionOptional };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map