@rplx/core 0.2.0

package/dist/index.mjs

@@ -0,0 +1,1096 @@
+// src/modules/registrar.ts
+function createRegistrar(options) {
+  const handlers = /* @__PURE__ */ new Map();
+  const warnOnOverwrite = options?.warnOnOverwrite ?? true;
+  return {
+    register(kind, id, handler) {
+      let kindMap = handlers.get(kind);
+      if (!kindMap) {
+        kindMap = /* @__PURE__ */ new Map();
+        handlers.set(kind, kindMap);
+      }
+      if (warnOnOverwrite && kindMap.has(id)) {
+        console.warn(`re-frame: overwriting ${kind} handler for: ${id}`);
+      }
+      kindMap.set(id, handler);
+      return handler;
+    },
+    get(kind, id) {
+      const kindMap = handlers.get(kind);
+      if (!kindMap) {
+        return void 0;
+      }
+      return kindMap.get(id);
+    },
+    has(kind, id) {
+      const kindMap = handlers.get(kind);
+      if (!kindMap) {
+        return false;
+      }
+      return kindMap.has(id);
+    },
+    clear(kind, id) {
+      if (kind === void 0) {
+        handlers.clear();
+      } else if (id === void 0) {
+        handlers.delete(kind);
+      } else {
+        const kindMap = handlers.get(kind);
+        if (kindMap) {
+          if (kindMap.has(id)) {
+            kindMap.delete(id);
+          } else {
+            console.warn(`re-frame: can't clear ${kind} handler for ${id}. Handler not found.`);
+          }
+        }
+      }
+    }
+  };
+}
+
+// src/modules/state.ts
+function createStateManager(initialState, onStateChange, onStateChangeForSubscriptions) {
+  let state = initialState;
+  const stateChanges = [];
+  let rafId = null;
+  const scheduleNotification = () => {
+    if (rafId !== null) return;
+    rafId = requestAnimationFrame(() => {
+      rafId = null;
+      if (stateChanges.length > 0) {
+        const latestState = stateChanges[stateChanges.length - 1];
+        stateChanges.length = 0;
+        if (onStateChange) {
+          onStateChange(latestState);
+        }
+        if (onStateChangeForSubscriptions) {
+          onStateChangeForSubscriptions(latestState);
+        }
+      }
+    });
+  };
+  return {
+    getState() {
+      return state;
+    },
+    setState(newState) {
+      const oldState = state;
+      if (!Object.is(oldState, newState)) {
+        state = newState;
+        stateChanges.push(newState);
+        scheduleNotification();
+      }
+    },
+    scheduleNotification
+  };
+}
+
+// src/modules/tracing.ts
+function createTracer(config = {}) {
+  const traceEnabled = config.enabled ?? false;
+  const traceCallbacks = /* @__PURE__ */ new Map();
+  const traces = [];
+  let traceIdCounter = 0;
+  const debounceTime = config.debounceTime ?? 50;
+  let debounceTimer = null;
+  let nextDeliveryTime = 0;
+  const deliverTraces = () => {
+    if (traces.length === 0) return;
+    const tracesToDeliver = [...traces];
+    traces.length = 0;
+    for (const [key, callback] of traceCallbacks.entries()) {
+      try {
+        callback(tracesToDeliver);
+      } catch (error) {
+        console.error(`Error in trace callback "${key}":`, error);
+      }
+    }
+    debounceTimer = null;
+    nextDeliveryTime = 0;
+  };
+  const scheduleTraceDelivery = () => {
+    const now = Date.now();
+    if (now < nextDeliveryTime - 25) {
+      return;
+    }
+    if (debounceTimer !== null) {
+      clearTimeout(debounceTimer);
+    }
+    nextDeliveryTime = now + debounceTime;
+    debounceTimer = setTimeout(() => {
+      deliverTraces();
+    }, debounceTime);
+  };
+  const emitEventTrace = (trace) => {
+    if (!traceEnabled) return;
+    const traceWithId = {
+      ...trace,
+      id: ++traceIdCounter
+    };
+    traces.push(traceWithId);
+    scheduleTraceDelivery();
+  };
+  const registerTraceCallback = (key, callback) => {
+    if (!traceEnabled) {
+      console.warn("Tracing is not enabled. Set tracing.enabled to true in StoreConfig.");
+      return;
+    }
+    traceCallbacks.set(key, callback);
+  };
+  const removeTraceCallback = (key) => {
+    traceCallbacks.delete(key);
+  };
+  return {
+    registerTraceCallback,
+    removeTraceCallback,
+    emitEventTrace
+  };
+}
+
+// src/modules/errorHandler.ts
+function createErrorHandler(initialHandler, initialConfig) {
+  let errorHandler = initialHandler || defaultErrorHandler;
+  let errorHandlerConfig = {
+    rethrow: false,
+    ...initialConfig
+  };
+  return {
+    register(handler, config) {
+      errorHandler = handler;
+      if (config) {
+        errorHandlerConfig = { ...errorHandlerConfig, ...config };
+      }
+    },
+    async handle(error, context) {
+      try {
+        await errorHandler(error, context, errorHandlerConfig);
+        if (errorHandlerConfig.rethrow) {
+          throw error;
+        }
+      } catch (handlerError) {
+        console.error("Error in error handler:", handlerError);
+        if (errorHandlerConfig.rethrow) {
+          throw error;
+        }
+      }
+    }
+  };
+}
+function defaultErrorHandler(error, context, config) {
+  const { eventKey, phase, interceptor } = context;
+  if (phase === "interceptor" && interceptor) {
+    console.error(
+      `Error in ${interceptor.direction} phase of interceptor "${interceptor.id || "unnamed"}" while handling event "${eventKey}":`,
+      error
+    );
+  } else if (phase === "effect" && interceptor) {
+    console.error(
+      `Error executing effect "${interceptor.id}" for event "${eventKey}":`,
+      error
+    );
+  } else if (phase === "subscription") {
+    console.error(
+      `Error in subscription "${eventKey}":`,
+      error
+    );
+  } else {
+    console.error(
+      `Error handling event "${eventKey}":`,
+      error
+    );
+  }
+}
+
+// src/modules/effects.ts
+function createEffectExecutor(deps) {
+  const { registrar, stateManager, errorHandler, dispatch, deregisterEvent, registerEffect } = deps;
+  async function execute(effectMap, eventKey, payload, effectsExecuted) {
+    if (effectMap.db !== void 0) {
+      const dbHandler = registrar.get("effect", "db");
+      if (dbHandler) {
+        const effectStart = Date.now();
+        try {
+          await dbHandler(effectMap.db, deps);
+          const effectEnd = Date.now();
+          if (effectsExecuted) {
+            effectsExecuted.push({
+              effectType: "db",
+              config: effectMap.db,
+              start: effectStart,
+              end: effectEnd,
+              duration: effectEnd - effectStart
+            });
+          }
+        } catch (error) {
+          const effectEnd = Date.now();
+          if (effectsExecuted) {
+            effectsExecuted.push({
+              effectType: "db",
+              config: effectMap.db,
+              start: effectStart,
+              end: effectEnd,
+              duration: effectEnd - effectStart,
+              error
+            });
+          }
+          await errorHandler.handle(error, {
+            eventKey,
+            payload,
+            phase: "effect",
+            interceptor: {
+              id: "db",
+              direction: "after"
+            }
+          });
+        }
+      }
+    }
+    const effectsWithoutDb = Object.entries(effectMap).filter(
+      ([key]) => key !== "db" && key !== "fx"
+    );
+    await Promise.all(
+      effectsWithoutDb.map(async ([effectType, config]) => {
+        if (config === void 0 || config === null) {
+          return;
+        }
+        const handler = registrar.get("effect", effectType);
+        if (!handler) {
+          console.warn(`No effect handler registered for "${String(effectType)}"`);
+          return;
+        }
+        const effectStart = Date.now();
+        try {
+          await handler(config, deps);
+          const effectEnd = Date.now();
+          if (effectsExecuted) {
+            effectsExecuted.push({
+              effectType,
+              config,
+              start: effectStart,
+              end: effectEnd,
+              duration: effectEnd - effectStart
+            });
+          }
+        } catch (error) {
+          const effectEnd = Date.now();
+          if (effectsExecuted) {
+            effectsExecuted.push({
+              effectType,
+              config,
+              start: effectStart,
+              end: effectEnd,
+              duration: effectEnd - effectStart,
+              error
+            });
+          }
+          await errorHandler.handle(error, {
+            eventKey,
+            payload,
+            phase: "effect",
+            interceptor: {
+              id: effectType,
+              direction: "after"
+            }
+          });
+        }
+      })
+    );
+    if (effectMap.fx !== void 0) {
+      const fxHandler = registrar.get("effect", "fx");
+      if (fxHandler) {
+        const effectStart = Date.now();
+        try {
+          await fxHandler(effectMap.fx, deps);
+          const effectEnd = Date.now();
+          if (effectsExecuted) {
+            effectsExecuted.push({
+              effectType: "fx",
+              config: effectMap.fx,
+              start: effectStart,
+              end: effectEnd,
+              duration: effectEnd - effectStart
+            });
+          }
+        } catch (error) {
+          const effectEnd = Date.now();
+          if (effectsExecuted) {
+            effectsExecuted.push({
+              effectType: "fx",
+              config: effectMap.fx,
+              start: effectStart,
+              end: effectEnd,
+              duration: effectEnd - effectStart,
+              error
+            });
+          }
+          await errorHandler.handle(error, {
+            eventKey,
+            payload,
+            phase: "effect",
+            interceptor: {
+              id: "fx",
+              direction: "after"
+            }
+          });
+        }
+      }
+    }
+  }
+  function registerBuiltInEffects() {
+    registerEffect("db", (newState) => {
+      stateManager.setState(newState);
+    });
+    registerEffect("dispatch", async (config) => {
+      if (!config || typeof config.event !== "string") {
+        console.error("re-frame: ignoring bad :dispatch value. Expected {event: string, payload: any}, but got:", config);
+        return;
+      }
+      await dispatch(config.event, config.payload);
+    });
+    registerEffect("dispatch-n", async (configs) => {
+      if (!Array.isArray(configs)) {
+        console.error("re-frame: ignoring bad :dispatch-n value. Expected an array, but got:", configs);
+        return;
+      }
+      for (const config of configs) {
+        if (config && config.event) {
+          await dispatch(config.event, config.payload);
+        }
+      }
+    });
+    registerEffect("dispatch-later", (value) => {
+      if (!Array.isArray(value)) {
+        console.error("re-frame: ignoring bad :dispatch-later value. Expected an array, but got:", value);
+        return;
+      }
+      for (const effect of value.filter((e) => e != null)) {
+        if (!effect || typeof effect.ms !== "number" || !effect.event) {
+          console.error("re-frame: ignoring bad :dispatch-later entry:", effect);
+          continue;
+        }
+        setTimeout(() => {
+          dispatch(effect.event, effect.payload);
+        }, effect.ms);
+      }
+    });
+    registerEffect("fx", async (seqOfEffects) => {
+      if (!Array.isArray(seqOfEffects)) {
+        console.warn('re-frame: ":fx" effect expects an array, but was given', typeof seqOfEffects);
+        return;
+      }
+      for (const effectTuple of seqOfEffects) {
+        if (effectTuple == null) {
+          continue;
+        }
+        const [effectKey, effectValue] = effectTuple;
+        if (effectKey === "db") {
+          console.warn('re-frame: ":fx" effect should not contain a :db effect. Use top-level :db instead.');
+          continue;
+        }
+        const handler = registrar.get("effect", effectKey);
+        if (!handler) {
+          console.warn(`re-frame: in ":fx" effect found "${effectKey}" which has no associated handler. Ignoring.`);
+          continue;
+        }
+        try {
+          await handler(effectValue, deps);
+        } catch (error) {
+          await errorHandler.handle(error, {
+            eventKey: `fx:${effectKey}`,
+            payload: effectValue,
+            phase: "effect",
+            interceptor: {
+              id: effectKey,
+              direction: "after"
+            }
+          });
+        }
+      }
+    });
+    registerEffect("deregister-event-handler", (value) => {
+      if (Array.isArray(value)) {
+        for (const eventKey of value) {
+          if (typeof eventKey === "string") {
+            deregisterEvent(eventKey);
+          }
+        }
+      } else if (typeof value === "string") {
+        deregisterEvent(value);
+      }
+    });
+  }
+  return {
+    execute,
+    registerBuiltInEffects
+  };
+}
+function mergeEffects(...effects) {
+  const result = {};
+  for (const effect of effects) {
+    for (const [key, value] of Object.entries(effect)) {
+      if (key === "dispatch-n" && Array.isArray(value)) {
+        result["dispatch-n"] = [
+          ...result["dispatch-n"] || [],
+          ...value
+        ];
+      } else if (key === "dispatch-later" && Array.isArray(value)) {
+        result["dispatch-later"] = [
+          ...result["dispatch-later"] || [],
+          ...value
+        ];
+      } else if (key === "fx" && Array.isArray(value)) {
+        result.fx = [
+          ...result.fx || [],
+          ...value
+        ];
+      } else if (key === "deregister-event-handler") {
+        if (Array.isArray(value)) {
+          const existing = result["deregister-event-handler"];
+          if (Array.isArray(existing)) {
+            result["deregister-event-handler"] = [...existing, ...value];
+          } else if (typeof existing === "string") {
+            result["deregister-event-handler"] = [existing, ...value];
+          } else {
+            result["deregister-event-handler"] = value;
+          }
+        } else if (typeof value === "string") {
+          const existing = result["deregister-event-handler"];
+          if (Array.isArray(existing)) {
+            result["deregister-event-handler"] = [...existing, value];
+          } else if (typeof existing === "string") {
+            result["deregister-event-handler"] = [existing, value];
+          } else {
+            result["deregister-event-handler"] = value;
+          }
+        }
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+
+// src/modules/events.ts
+function createEventManager(deps) {
+  const { registrar, stateManager, effectExecutor, errorHandler, tracer, coeffectProviders } = deps;
+  function dbHandlerToInterceptor(handler) {
+    return {
+      id: "db-handler",
+      before: (context) => {
+        const event = context.coeffects.event;
+        const newState = handler(context.coeffects, event);
+        return {
+          ...context,
+          effects: {
+            ...context.effects,
+            db: newState
+          }
+        };
+      }
+    };
+  }
+  function fxHandlerToInterceptor(handler) {
+    return {
+      id: "fx-handler",
+      before: (context) => {
+        const event = context.coeffects.event;
+        const effects = handler(context.coeffects, event);
+        return {
+          ...context,
+          effects: {
+            ...context.effects,
+            ...effects
+          }
+        };
+      }
+    };
+  }
+  function registerEventDb(eventKey, handler, interceptors) {
+    if (registrar.has("event", eventKey)) {
+      console.warn(`Event handler for "${eventKey}" is being overwritten`);
+    }
+    const handlerInterceptor = dbHandlerToInterceptor(handler);
+    const chain = interceptors ? [...interceptors, handlerInterceptor] : [handlerInterceptor];
+    registrar.register("event", eventKey, chain);
+  }
+  function registerEvent(eventKey, handler, interceptors) {
+    if (registrar.has("event", eventKey)) {
+      console.warn(`Event handler for "${eventKey}" is being overwritten`);
+    }
+    const handlerInterceptor = fxHandlerToInterceptor(handler);
+    const chain = interceptors ? [...interceptors, handlerInterceptor] : [handlerInterceptor];
+    registrar.register("event", eventKey, chain);
+  }
+  function deregisterEvent(eventKey) {
+    registrar.clear("event", eventKey);
+  }
+  async function handleEvent(eventKey, payload) {
+    const startTime = Date.now();
+    const stateBefore = stateManager.getState();
+    const interceptors = registrar.get("event", eventKey);
+    if (!interceptors || interceptors.length === 0) {
+      console.warn(`No handler registered for event "${eventKey}"`);
+      return;
+    }
+    const computedCoeffects = {};
+    for (const key in coeffectProviders) {
+      const provider = coeffectProviders[key];
+      computedCoeffects[key] = provider();
+    }
+    const initialContext = {
+      db: stateManager.getState(),
+      event: payload,
+      ...computedCoeffects
+    };
+    let context = {
+      coeffects: initialContext,
+      effects: {},
+      queue: [...interceptors],
+      // Copy to avoid mutation
+      stack: []
+    };
+    const effectsExecuted = [];
+    let eventError;
+    let effectMap = {};
+    try {
+      while (context.queue.length > 0) {
+        const interceptor = context.queue.shift();
+        context.stack.push(interceptor);
+        if (interceptor.before) {
+          try {
+            context = interceptor.before(context);
+          } catch (error) {
+            eventError = error;
+            await errorHandler.handle(error, {
+              eventKey,
+              payload,
+              phase: "interceptor",
+              interceptor: {
+                id: interceptor.id,
+                direction: "before"
+              }
+            });
+            break;
+          }
+        }
+      }
+      if (!eventError) {
+        while (context.stack.length > 0) {
+          const interceptor = context.stack.pop();
+          if (interceptor.after) {
+            try {
+              context = interceptor.after(context);
+            } catch (error) {
+              eventError = error;
+              await errorHandler.handle(error, {
+                eventKey,
+                payload,
+                phase: "interceptor",
+                interceptor: {
+                  id: interceptor.id,
+                  direction: "after"
+                }
+              });
+              break;
+            }
+          }
+        }
+      }
+      effectMap = context.effects;
+      if (!eventError) {
+        await effectExecutor.execute(context.effects, eventKey, payload, effectsExecuted);
+      }
+    } catch (error) {
+      eventError = error;
+      await errorHandler.handle(error, {
+        eventKey,
+        payload,
+        phase: "interceptor"
+      });
+    }
+    const stateAfter = stateManager.getState();
+    const duration = Date.now() - startTime;
+    const interceptorInfo = interceptors.map((interceptor, index) => ({
+      id: interceptor.id,
+      order: index
+    }));
+    tracer.emitEventTrace({
+      eventKey,
+      payload,
+      timestamp: startTime,
+      stateBefore,
+      stateAfter,
+      interceptors: interceptorInfo,
+      effectMap: eventError ? {} : effectMap,
+      effectsExecuted,
+      duration,
+      error: eventError
+    });
+  }
+  return {
+    registerEventDb,
+    registerEvent,
+    deregisterEvent,
+    handleEvent
+  };
+}
+
+// src/modules/router.ts
+function createRouter(deps) {
+  const { eventManager } = deps;
+  const eventQueue = [];
+  let isProcessing = false;
+  async function processEvent(eventKey, payload) {
+    await eventManager.handleEvent(eventKey, payload);
+  }
+  async function processQueue() {
+    if (isProcessing) return;
+    isProcessing = true;
+    try {
+      while (eventQueue.length > 0) {
+        const event = eventQueue.shift();
+        await processEvent(event.eventKey, event.payload);
+      }
+    } finally {
+      isProcessing = false;
+    }
+  }
+  function dispatch(eventKey, payload) {
+    return new Promise((resolve, reject) => {
+      eventQueue.push({ eventKey, payload });
+      if (!isProcessing) {
+        processQueue().then(resolve).catch(reject);
+      } else {
+        resolve();
+      }
+    });
+  }
+  async function flush() {
+    await processQueue();
+  }
+  return {
+    dispatch,
+    flush
+  };
+}
+
+// src/modules/subscription.ts
+var Subscription = class {
+  constructor(key, params) {
+    this.key = key;
+    this.params = params;
+  }
+};
+var SubscriptionRegistry = class {
+  constructor() {
+    this.subscriptions = /* @__PURE__ */ new Map();
+    // Map of cache keys to shared Subscription objects
+    this.subscriptionCache = /* @__PURE__ */ new Map();
+    // WeakMap for computed results - automatically GC'd when Subscription is no longer referenced
+    this.resultCache = /* @__PURE__ */ new WeakMap();
+    // Reference counting: track how many active subscriptions exist for each Subscription object
+    this.refCounts = /* @__PURE__ */ new WeakMap();
+    // Listeners for each subscription
+    this.listeners = /* @__PURE__ */ new WeakMap();
+  }
+  register(key, config) {
+    this.subscriptions.set(key, config);
+  }
+  /**
+   * Get or create a shared Subscription object for the given key+params
+   * Returns the same object for the same key+params (like re-frame)
+   */
+  getSubscription(key, params) {
+    const cacheKey = this.getCacheKey(key, params);
+    let subscription = this.subscriptionCache.get(cacheKey);
+    if (!subscription) {
+      subscription = new Subscription(key, params);
+      this.subscriptionCache.set(cacheKey, subscription);
+      this.refCounts.set(subscription, 0);
+      this.listeners.set(subscription, /* @__PURE__ */ new Set());
+    }
+    return subscription;
+  }
+  subscribe(state, key, params, callback, onError) {
+    const subscription = this.getSubscription(key, params);
+    const currentCount = this.refCounts.get(subscription) || 0;
+    this.refCounts.set(subscription, currentCount + 1);
+    const result = this.query(state, key, params, onError);
+    callback(result);
+    const listeners = this.listeners.get(subscription);
+    listeners.add(callback);
+    return () => {
+      listeners.delete(callback);
+      const count = this.refCounts.get(subscription) || 0;
+      const newCount = Math.max(0, count - 1);
+      this.refCounts.set(subscription, newCount);
+      if (newCount <= 0 && listeners.size === 0) {
+        const cacheKey = this.getCacheKey(key, params);
+        this.subscriptionCache.delete(cacheKey);
+      }
+    };
+  }
+  query(state, key, params, onError) {
+    const config = this.subscriptions.get(key);
+    if (!config) {
+      const error = new Error(`Subscription "${key}" not registered`);
+      if (onError) {
+        onError(error, key, params);
+        return void 0;
+      }
+      console.error(error.message);
+      return void 0;
+    }
+    const subscription = this.getSubscription(key, params);
+    const cached = this.resultCache.get(subscription);
+    if (cached && cached.state === state) {
+      return cached.result;
+    }
+    let result;
+    try {
+      if (config.compute) {
+        result = config.compute(state, ...params);
+      } else if (config.deps && config.combine) {
+        const depResults = config.deps.map((depKey) => this.query(state, depKey, [], onError));
+        result = config.combine(depResults, ...params);
+      } else {
+        const error = new Error(`Invalid subscription config for "${key}"`);
+        if (onError) {
+          onError(error, key, params);
+          return void 0;
+        }
+        console.error(error.message);
+        return void 0;
+      }
+    } catch (error) {
+      if (onError) {
+        onError(error, key, params);
+      } else {
+        console.error(`Error computing subscription "${key}":`, error);
+      }
+      return cached?.result ?? void 0;
+    }
+    this.resultCache.set(subscription, { state, result });
+    return result;
+  }
+  notifyListeners(newState) {
+    for (const subscription of this.subscriptionCache.values()) {
+      const listeners = this.listeners.get(subscription);
+      if (!listeners || listeners.size === 0) {
+        continue;
+      }
+      const oldCached = this.resultCache.get(subscription);
+      const oldResult = oldCached?.result;
+      const newResult = this.query(newState, subscription.key, subscription.params, void 0);
+      if (!oldCached || !this.deepEqual(oldResult, newResult)) {
+        listeners.forEach((callback) => callback(newResult));
+      }
+    }
+  }
+  getCacheKey(key, params) {
+    return `${key}:${JSON.stringify(params)}`;
+  }
+  deepEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+  }
+};
+
+// src/modules/subscriptions.ts
+function createSubscriptionManager(deps) {
+  const { stateManager, errorHandler } = deps;
+  const registry = new SubscriptionRegistry();
+  function createSubscriptionErrorHandler() {
+    return (error, subKey, subParams) => {
+      errorHandler.handle(error, {
+        eventKey: `subscription:${subKey}`,
+        payload: subParams,
+        phase: "subscription"
+      }).catch(() => {
+      });
+    };
+  }
+  function registerSubscription(key, config) {
+    registry.register(key, config);
+  }
+  function subscribe(key, params, callback) {
+    const onError = createSubscriptionErrorHandler();
+    return registry.subscribe(
+      stateManager.getState(),
+      key,
+      params,
+      callback,
+      onError
+    );
+  }
+  function query(key, params) {
+    const onError = createSubscriptionErrorHandler();
+    return registry.query(
+      stateManager.getState(),
+      key,
+      params,
+      onError
+    );
+  }
+  function getSubscription(key, params) {
+    return registry.getSubscription(key, params);
+  }
+  function notifyListeners(newState) {
+    registry.notifyListeners(newState);
+  }
+  return {
+    registerSubscription,
+    subscribe,
+    query,
+    getSubscription,
+    notifyListeners
+  };
+}
+
+// src/modules/store.ts
+function createStore(config) {
+  const registrar = createRegistrar();
+  const coeffectProviders = config.coeffects || {};
+  const errorHandlerManager = createErrorHandler(
+    config.errorHandler?.handler,
+    config.errorHandler?.rethrow !== void 0 ? { rethrow: config.errorHandler.rethrow } : void 0
+  );
+  let subscriptionManagerRef = null;
+  const stateManager = createStateManager(
+    config.initialState,
+    config.onStateChange,
+    (state) => {
+      if (subscriptionManagerRef) {
+        subscriptionManagerRef.notifyListeners(state);
+      }
+    }
+  );
+  const subscriptionManager = createSubscriptionManager({
+    stateManager,
+    errorHandler: errorHandlerManager
+  });
+  subscriptionManagerRef = subscriptionManager;
+  const tracer = createTracer(config.tracing);
+  let dispatchFn = () => {
+    throw new Error("Router not initialized yet. This should not happen during store creation.");
+  };
+  let deregisterEventFn = () => {
+    throw new Error("Event manager not initialized yet.");
+  };
+  let registerEffectFn = () => {
+    throw new Error("Event manager not initialized yet.");
+  };
+  const effectExecutor = createEffectExecutor({
+    registrar,
+    stateManager,
+    errorHandler: errorHandlerManager,
+    dispatch: (eventKey, payload) => {
+      return dispatchFn(eventKey, payload);
+    },
+    deregisterEvent: (eventKey) => {
+      deregisterEventFn(eventKey);
+    },
+    registerEffect: (effectType, handler) => {
+      registerEffectFn(effectType, handler);
+    }
+  });
+  const eventManager = createEventManager({
+    registrar,
+    stateManager,
+    effectExecutor,
+    errorHandler: errorHandlerManager,
+    tracer,
+    coeffectProviders
+  });
+  deregisterEventFn = (eventKey) => {
+    eventManager.deregisterEvent(eventKey);
+  };
+  registerEffectFn = (effectType, handler) => {
+    registrar.register("effect", effectType, handler);
+  };
+  const router = createRouter({
+    eventManager
+  });
+  dispatchFn = (eventKey, payload) => {
+    return router.dispatch(eventKey, payload);
+  };
+  effectExecutor.registerBuiltInEffects();
+  return {
+    // Event registration
+    registerEventDb: (eventKey, handler, interceptors) => {
+      eventManager.registerEventDb(eventKey, handler, interceptors);
+    },
+    registerEvent: (eventKey, handler, interceptors) => {
+      eventManager.registerEvent(eventKey, handler, interceptors);
+    },
+    deregisterEvent: (eventKey) => {
+      eventManager.deregisterEvent(eventKey);
+    },
+    // Effect registration
+    registerEffect: (effectType, handler) => {
+      if (registrar.has("effect", effectType)) {
+        console.warn(`Effect handler for "${effectType}" is being overwritten`);
+      }
+      registrar.register("effect", effectType, handler);
+    },
+    // Event dispatching
+    dispatch: (eventKey, payload) => {
+      return router.dispatch(eventKey, payload);
+    },
+    flush: async () => {
+      await router.flush();
+    },
+    // State access
+    getState: () => {
+      return stateManager.getState();
+    },
+    // Interceptor inspection
+    getInterceptors: (eventKey) => {
+      return registrar.get("event", eventKey);
+    },
+    // Error handling
+    registerErrorHandler: (handler, config2) => {
+      errorHandlerManager.register(handler, config2);
+    },
+    // Subscriptions
+    registerSubscription: (key, config2) => {
+      subscriptionManager.registerSubscription(key, config2);
+    },
+    subscribe: (key, params, callback) => {
+      return subscriptionManager.subscribe(key, params, callback);
+    },
+    query: (key, params) => {
+      return subscriptionManager.query(key, params);
+    },
+    getSubscription: (key, params) => {
+      return subscriptionManager.getSubscription(key, params);
+    },
+    // Tracing
+    registerTraceCallback: (key, callback) => {
+      tracer.registerTraceCallback(key, callback);
+    },
+    removeTraceCallback: (key) => {
+      tracer.removeTraceCallback(key);
+    }
+  };
+}
+
+// src/modules/interceptor.ts
+function path(pathKeys) {
+  return {
+    id: `path-${pathKeys.join(".")}`,
+    before: (context) => {
+      let value = context.coeffects.db;
+      for (const key of pathKeys) {
+        value = value?.[key];
+      }
+      return {
+        ...context,
+        coeffects: {
+          ...context.coeffects,
+          _originalDb: context.coeffects.db,
+          _pathKeys: pathKeys,
+          db: value
+        }
+      };
+    },
+    after: (context) => {
+      const pathKeys2 = context.coeffects._pathKeys;
+      const originalDb = context.coeffects._originalDb;
+      const focusedState = context.effects.db;
+      if (pathKeys2 && originalDb !== void 0 && focusedState !== void 0) {
+        let newDb = { ...originalDb };
+        let current = newDb;
+        for (let i = 0; i < pathKeys2.length - 1; i++) {
+          current[pathKeys2[i]] = { ...current[pathKeys2[i]] };
+          current = current[pathKeys2[i]];
+        }
+        current[pathKeys2[pathKeys2.length - 1]] = focusedState;
+        return {
+          ...context,
+          coeffects: {
+            ...context.coeffects,
+            db: originalDb
+          },
+          effects: {
+            ...context.effects,
+            db: newDb
+          }
+        };
+      }
+      if (pathKeys2 && originalDb !== void 0) {
+        return {
+          ...context,
+          coeffects: {
+            ...context.coeffects,
+            db: originalDb
+          }
+        };
+      }
+      return context;
+    }
+  };
+}
+function debug() {
+  return {
+    id: "debug",
+    before: (context) => {
+      console.group("Event");
+      console.log("Coeffects:", context.coeffects);
+      return context;
+    },
+    after: (context) => {
+      console.log("New State:", context.coeffects.db);
+      console.log("Effects:", context.effects);
+      console.groupEnd();
+      return context;
+    }
+  };
+}
+function after(fn) {
+  return {
+    id: "after",
+    after: (context) => {
+      fn(context.coeffects.db, context.effects);
+      return context;
+    }
+  };
+}
+function injectCofx(key, value) {
+  return {
+    id: `inject-${key}`,
+    before: (context) => {
+      return {
+        ...context,
+        coeffects: {
+          ...context.coeffects,
+          [key]: value
+        }
+      };
+    }
+  };
+}
+function validate(schema) {
+  return {
+    id: "validate",
+    after: (context) => {
+      const result = schema(context.coeffects.db);
+      if (result !== true) {
+        console.error("State validation failed:", result);
+      }
+      return context;
+    }
+  };
+}
+export {
+  Subscription,
+  SubscriptionRegistry,
+  after,
+  createStore,
+  debug,
+  defaultErrorHandler,
+  injectCofx,
+  mergeEffects,
+  path,
+  validate
+};