@effuse/store 1.0.0

package/dist/index.cjs

@@ -0,0 +1,1462 @@
+'use strict';
+
+var effect = require('effect');
+var core = require('@effuse/core');
+
+// src/core/store.ts
+var createAtomicState = (initial) => {
+  const ref = effect.Effect.runSync(effect.SubscriptionRef.make(initial));
+  return {
+    get: () => effect.Effect.runSync(effect.SubscriptionRef.get(ref)),
+    set: (value) => {
+      effect.Effect.runSync(effect.SubscriptionRef.set(ref, value));
+    },
+    update: (fn) => {
+      effect.Effect.runSync(effect.SubscriptionRef.update(ref, fn));
+    }
+  };
+};
+var STORAGE_PREFIX = "effuse-store:";
+var ROOT_SCOPE_ID = "__root__";
+var SCOPE_PREFIX = "scope_";
+var DEFAULT_TIMEOUT_MS = 5e3;
+effect.Duration.millis(DEFAULT_TIMEOUT_MS);
+var DEFAULT_RETRY_INITIAL_DELAY_MS = 100;
+var DEFAULT_RETRY_MAX_DELAY_MS = 5e3;
+var DEFAULT_RETRY_BACKOFF_FACTOR = 2;
+var StoreConstants = {
+  STORAGE_PREFIX,
+  ROOT_SCOPE_ID,
+  SCOPE_PREFIX,
+  DEBUG_PREFIX: "[store]",
+  DEVTOOLS_PREFIX: "Effuse:",
+  DEFAULT_TIMEOUT_MS
+};
+var StoreConfigOptions = {
+  persistByDefault: effect.Config.boolean("EFFUSE_STORE_PERSIST").pipe(
+    effect.Config.withDefault(false)
+  ),
+  storagePrefix: effect.Config.string("EFFUSE_STORE_PREFIX").pipe(
+    effect.Config.withDefault(STORAGE_PREFIX)
+  ),
+  debug: effect.Config.boolean("EFFUSE_STORE_DEBUG").pipe(effect.Config.withDefault(false)),
+  devtools: effect.Config.boolean("EFFUSE_STORE_DEVTOOLS").pipe(
+    effect.Config.withDefault(false)
+  )
+};
+var loadStoreConfigValues = effect.Effect.all({
+  persistByDefault: StoreConfigOptions.persistByDefault,
+  storagePrefix: StoreConfigOptions.storagePrefix,
+  debug: StoreConfigOptions.debug,
+  devtools: StoreConfigOptions.devtools
+}).pipe(
+  effect.Effect.catchAll(
+    () => effect.Effect.succeed({
+      persistByDefault: false,
+      storagePrefix: STORAGE_PREFIX,
+      debug: false,
+      devtools: false
+    })
+  )
+);
+var cachedConfig = null;
+var getStoreConfig = () => {
+  if (!cachedConfig) {
+    cachedConfig = effect.Effect.runSync(loadStoreConfigValues);
+  }
+  return cachedConfig;
+};
+var resetStoreConfigCache = () => {
+  cachedConfig = null;
+};
+var createMiddlewareManager = () => {
+  const middlewares = [];
+  return {
+    add: (middleware) => {
+      middlewares.push(middleware);
+      return () => {
+        const idx = middlewares.indexOf(middleware);
+        if (idx > -1) middlewares.splice(idx, 1);
+      };
+    },
+    remove: (middleware) => {
+      const idx = middlewares.indexOf(middleware);
+      if (idx > -1) middlewares.splice(idx, 1);
+    },
+    execute: (state, action, args) => effect.Array.reduce(middlewares, state, (acc, mw) => mw(acc, action, args) ?? acc),
+    getAll: () => [...middlewares]
+  };
+};
+var StoreNotFoundError = class extends effect.Data.TaggedError("StoreNotFoundError") {
+  get message() {
+    return `Store "${this.name}" not found`;
+  }
+};
+var StoreAlreadyExistsError = class extends effect.Data.TaggedError(
+  "StoreAlreadyExistsError"
+) {
+  get message() {
+    return `Store "${this.name}" already exists`;
+  }
+};
+var ActionNotFoundError = class extends effect.Data.TaggedError(
+  "ActionNotFoundError"
+) {
+};
+var TimeoutError = class extends effect.Data.TaggedError("TimeoutError") {
+  get message() {
+    return `Operation timed out after ${String(this.ms)}ms`;
+  }
+};
+var CancellationError = class extends effect.Data.TaggedError("CancellationError") {
+};
+var ValidationError = class extends effect.Data.TaggedError("ValidationError") {
+  get message() {
+    return `Validation failed: ${this.errors.join(", ")}`;
+  }
+};
+(class extends effect.Data.TaggedError("RaceEmptyError") {
+  get message() {
+    return "raceAll requires at least one effect";
+  }
+});
+var HydrationError = class extends effect.Data.TaggedError("HydrationError") {
+  get message() {
+    return "Failed to hydrate stores";
+  }
+};
+
+// src/registry/index.ts
+var stores = /* @__PURE__ */ new Map();
+var registerStore = (name, store) => {
+  if (stores.has(name) && getStoreConfig().debug) {
+    console.warn(`[store] Overwriting existing store: ${name}`);
+  }
+  stores.set(name, store);
+};
+var getStore = (name) => {
+  const store = stores.get(name);
+  if (!store) {
+    throw new StoreNotFoundError({ name });
+  }
+  return store;
+};
+var hasStore = (name) => stores.has(name);
+var removeStore = (name) => stores.delete(name);
+var clearStores = () => {
+  stores.clear();
+};
+var getStoreNames = () => Array.from(stores.keys());
+var localStorageAdapter = {
+  getItem: (key) => effect.Effect.try({
+    try: () => effect.Option.fromNullable(localStorage.getItem(key)),
+    catch: () => effect.Option.none()
+  }).pipe(effect.Effect.catchAll(() => effect.Effect.succeed(effect.Option.none()))),
+  setItem: (key, value) => effect.Effect.try(() => {
+    localStorage.setItem(key, value);
+  }).pipe(effect.Effect.catchAll(() => effect.Effect.void)),
+  removeItem: (key) => effect.Effect.try(() => {
+    localStorage.removeItem(key);
+  }).pipe(effect.Effect.catchAll(() => effect.Effect.void))
+};
+var runAdapter = {
+  getItem: (adapter, key) => effect.Effect.runSync(
+    adapter.getItem(key).pipe(effect.Effect.map((opt) => effect.Option.getOrNull(opt)))
+  ),
+  setItem: (adapter, key, value) => {
+    effect.Effect.runSync(adapter.setItem(key, value));
+  },
+  removeItem: (adapter, key) => {
+    effect.Effect.runSync(adapter.removeItem(key));
+  }
+};
+var createCancellationToken = () => {
+  let cancelled = false;
+  const callbacks = /* @__PURE__ */ new Set();
+  return {
+    get isCancelled() {
+      return cancelled;
+    },
+    cancel: () => {
+      if (!cancelled) {
+        cancelled = true;
+        for (const cb of callbacks) cb();
+        callbacks.clear();
+      }
+    },
+    throwIfCancelled: () => {
+      if (cancelled)
+        throw new CancellationError({ message: "Operation was cancelled" });
+    },
+    onCancel: (callback) => {
+      if (cancelled) {
+        callback();
+        return () => {
+        };
+      }
+      callbacks.add(callback);
+      return () => callbacks.delete(callback);
+    }
+  };
+};
+var createCancellationScope = () => {
+  const children = /* @__PURE__ */ new Set();
+  const token = createCancellationToken();
+  return {
+    token,
+    createChild: () => {
+      const child = createCancellationToken();
+      children.add(child);
+      token.onCancel(() => {
+        child.cancel();
+      });
+      return child;
+    },
+    dispose: () => {
+      token.cancel();
+      for (const child of children) child.cancel();
+      children.clear();
+    }
+  };
+};
+var runWithAbortSignal = (effect$1, signal5) => {
+  if (signal5.aborted) {
+    return effect.Effect.fail(
+      new CancellationError({ message: "Operation was cancelled" })
+    );
+  }
+  return effect.Effect.async((resume) => {
+    const onAbort = () => {
+      resume(
+        effect.Effect.fail(
+          new CancellationError({ message: "Operation was cancelled" })
+        )
+      );
+    };
+    signal5.addEventListener("abort", onAbort, { once: true });
+    effect.Effect.runPromise(effect$1).then((result) => {
+      signal5.removeEventListener("abort", onAbort);
+      resume(effect.Effect.succeed(result));
+    }).catch((error) => {
+      signal5.removeEventListener("abort", onAbort);
+      resume(effect.Effect.fail(error));
+    });
+  });
+};
+
+// src/core/store.ts
+var getSnapshot = (signalMap) => {
+  const snapshot = {};
+  for (const [key, sig] of signalMap) {
+    snapshot[key] = sig.value;
+  }
+  return snapshot;
+};
+var createStore = (name, definition, options) => {
+  const config = getStoreConfig();
+  const shouldPersist = effect.pipe(
+    effect.Option.fromNullable(options),
+    effect.Option.flatMap((o) => effect.Option.fromNullable(o.persist)),
+    effect.Option.getOrElse(() => config.persistByDefault)
+  );
+  const storageKey = effect.pipe(
+    effect.Option.fromNullable(options),
+    effect.Option.flatMap((o) => effect.Option.fromNullable(o.storageKey)),
+    effect.Option.getOrElse(() => `${config.storagePrefix}${name}`)
+  );
+  const enableDevtools = effect.pipe(
+    effect.Option.fromNullable(options),
+    effect.Option.flatMap((o) => effect.Option.fromNullable(o.devtools)),
+    effect.Option.getOrElse(() => config.debug)
+  );
+  const adapter = effect.pipe(
+    effect.Option.fromNullable(options),
+    effect.Option.flatMap((o) => effect.Option.fromNullable(o.storage)),
+    effect.Option.getOrElse(() => localStorageAdapter)
+  );
+  if (config.debug) {
+    console.log(`[store] Creating: ${name}`);
+  }
+  const internals = {
+    signalMap: /* @__PURE__ */ new Map(),
+    initialState: {},
+    actions: {},
+    subscribers: /* @__PURE__ */ new Set(),
+    keySubscribers: /* @__PURE__ */ new Map(),
+    computedSelectors: /* @__PURE__ */ new Map(),
+    isBatching: false,
+    pendingActions: /* @__PURE__ */ new Map()
+  };
+  const middlewareManager = createMiddlewareManager();
+  for (const [key, value] of Object.entries(definition)) {
+    if (typeof value === "function") {
+      internals.actions[key] = value;
+    } else {
+      internals.initialState[key] = value;
+      internals.signalMap.set(key, core.signal(value));
+    }
+  }
+  const atomicState = createAtomicState({ ...internals.initialState });
+  if (shouldPersist) {
+    effect.pipe(
+      runAdapter.getItem(adapter, storageKey),
+      effect.Option.fromNullable,
+      effect.Option.flatMap(
+        (saved) => effect.Effect.runSync(
+          effect.Effect.try(() => JSON.parse(saved)).pipe(
+            effect.Effect.map(effect.Option.some),
+            effect.Effect.catchAll(
+              () => effect.Effect.succeed(effect.Option.none())
+            )
+          )
+        )
+      ),
+      effect.Option.map((parsed) => {
+        for (const [key, value] of Object.entries(parsed)) {
+          const sig = internals.signalMap.get(key);
+          if (sig) sig.value = value;
+        }
+        atomicState.set({ ...atomicState.get(), ...parsed });
+      })
+    );
+  }
+  const notifySubscribers = () => {
+    if (internals.isBatching) return;
+    for (const callback of internals.subscribers) callback();
+  };
+  const notifyKeySubscribers = (key, value) => {
+    if (internals.isBatching) return;
+    const subs = internals.keySubscribers.get(key);
+    if (subs) for (const cb of subs) cb(value);
+  };
+  const persistState = () => {
+    if (!shouldPersist) return;
+    const snapshot = getSnapshot(internals.signalMap);
+    runAdapter.setItem(adapter, storageKey, JSON.stringify(snapshot));
+  };
+  const updateComputed = () => {
+    const snapshot = getSnapshot(internals.signalMap);
+    for (const [selector, sig] of internals.computedSelectors) {
+      const newValue = selector(snapshot);
+      if (sig.value !== newValue) sig.value = newValue;
+    }
+  };
+  const stateProxy = new Proxy({}, {
+    get(_, prop) {
+      const sig = internals.signalMap.get(prop);
+      if (sig) return sig;
+      const action = internals.actions[prop];
+      if (action) return action.bind(stateProxy);
+      return void 0;
+    },
+    set(_, prop, value) {
+      if (!internals.signalMap.has(prop)) return false;
+      const sig = internals.signalMap.get(prop);
+      if (!sig) return false;
+      const newState = middlewareManager.execute(
+        { ...atomicState.get(), [prop]: value },
+        `set:${prop}`,
+        [value]
+      );
+      sig.value = newState[prop];
+      atomicState.update((s) => ({ ...s, [prop]: newState[prop] }));
+      if (enableDevtools) {
+        const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+        console.groupCollapsed(
+          `%caction %c${name}/set:${prop} %c@ ${time}`,
+          "color: gray; font-weight: lighter;",
+          "color: inherit; font-weight: bold;",
+          "color: gray; font-weight: lighter;"
+        );
+        console.log(
+          "%cprev state",
+          "color: #9E9E9E; font-weight: bold;",
+          atomicState.get()
+        );
+        console.log("%caction", "color: #03A9F4; font-weight: bold;", {
+          type: `set:${prop}`,
+          payload: value
+        });
+        console.log("%cnext state", "color: #4CAF50; font-weight: bold;", {
+          ...atomicState.get(),
+          [prop]: newState[prop]
+        });
+        console.groupEnd();
+      }
+      notifySubscribers();
+      notifyKeySubscribers(prop, newState[prop]);
+      persistState();
+      updateComputed();
+      return true;
+    }
+  });
+  const boundActions = {};
+  for (const [key, action] of Object.entries(internals.actions)) {
+    boundActions[key] = (...args) => {
+      const prevState = enableDevtools ? getSnapshot(internals.signalMap) : void 0;
+      const existingToken = internals.pendingActions.get(key);
+      if (existingToken) {
+        existingToken.cancel();
+      }
+      const result = action.apply(stateProxy, args);
+      if (result instanceof Promise) {
+        const token = createCancellationToken();
+        internals.pendingActions.set(key, token);
+        return result.then((value) => {
+          if (!token.isCancelled) {
+            internals.pendingActions.delete(key);
+            const currentState2 = getSnapshot(internals.signalMap);
+            middlewareManager.execute(currentState2, key, args);
+            if (enableDevtools) {
+              const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+              console.groupCollapsed(
+                `%caction %c${name}/${key} (async) %c@ ${time}`,
+                "color: gray; font-weight: lighter;",
+                "color: inherit; font-weight: bold;",
+                "color: gray; font-weight: lighter;"
+              );
+              console.log(
+                "%cprev state",
+                "color: #9E9E9E; font-weight: bold;",
+                prevState
+              );
+              console.log("%caction", "color: #03A9F4; font-weight: bold;", {
+                type: `${name}/${key}`,
+                payload: args
+              });
+              console.log(
+                "%cnext state",
+                "color: #4CAF50; font-weight: bold;",
+                currentState2
+              );
+              console.groupEnd();
+            }
+            notifySubscribers();
+          }
+          return value;
+        }).catch((error) => {
+          internals.pendingActions.delete(key);
+          throw error;
+        });
+      }
+      const currentState = getSnapshot(internals.signalMap);
+      middlewareManager.execute(currentState, key, args);
+      if (enableDevtools) {
+        const time = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+        console.groupCollapsed(
+          `%caction %c${name}/${key} %c@ ${time}`,
+          "color: gray; font-weight: lighter;",
+          "color: inherit; font-weight: bold;",
+          "color: gray; font-weight: lighter;"
+        );
+        console.log(
+          "%cprev state",
+          "color: #9E9E9E; font-weight: bold;",
+          prevState
+        );
+        console.log("%caction", "color: #03A9F4; font-weight: bold;", {
+          type: `${name}/${key}`,
+          payload: args
+        });
+        console.log(
+          "%cnext state",
+          "color: #4CAF50; font-weight: bold;",
+          currentState
+        );
+        console.groupEnd();
+      }
+      notifySubscribers();
+      return result;
+    };
+  }
+  const storeState = {};
+  for (const [key, sig] of internals.signalMap) storeState[key] = sig;
+  for (const [key, action] of Object.entries(boundActions))
+    storeState[key] = action;
+  const store = {
+    name,
+    state: storeState,
+    subscribe: (callback) => {
+      internals.subscribers.add(callback);
+      return () => {
+        internals.subscribers.delete(callback);
+      };
+    },
+    subscribeToKey: (key, callback) => {
+      const keyStr = String(key);
+      let subs = internals.keySubscribers.get(keyStr);
+      if (!subs) {
+        subs = /* @__PURE__ */ new Set();
+        internals.keySubscribers.set(keyStr, subs);
+      }
+      const typedCallback = callback;
+      subs.add(typedCallback);
+      return () => {
+        const subsSet = internals.keySubscribers.get(keyStr);
+        if (effect.Predicate.isNotNullable(subsSet)) {
+          subsSet.delete(typedCallback);
+        }
+      };
+    },
+    getSnapshot: () => getSnapshot(internals.signalMap),
+    computed: (selector) => {
+      const selectorKey = selector;
+      const existing = internals.computedSelectors.get(selectorKey);
+      if (existing) return existing;
+      const initial = selector(getSnapshot(internals.signalMap));
+      const sig = core.signal(initial);
+      internals.computedSelectors.set(selectorKey, sig);
+      return sig;
+    },
+    batch: (updates) => {
+      internals.isBatching = true;
+      updates();
+      internals.isBatching = false;
+      notifySubscribers();
+      persistState();
+      updateComputed();
+    },
+    reset: () => {
+      for (const [key, value] of Object.entries(internals.initialState)) {
+        const sig = internals.signalMap.get(key);
+        if (sig) sig.value = value;
+      }
+      atomicState.set({ ...internals.initialState });
+      notifySubscribers();
+      persistState();
+      updateComputed();
+    },
+    use: (middleware) => middlewareManager.add(middleware),
+    toJSON: () => getSnapshot(internals.signalMap),
+    update: (updater) => {
+      const draft = { ...getSnapshot(internals.signalMap) };
+      updater(draft);
+      internals.isBatching = true;
+      for (const [key, val] of Object.entries(draft)) {
+        const sig = internals.signalMap.get(key);
+        if (sig && sig.value !== val) {
+          sig.value = val;
+          atomicState.update((s) => ({ ...s, [key]: val }));
+        }
+      }
+      internals.isBatching = false;
+      notifySubscribers();
+      persistState();
+      updateComputed();
+    },
+    select: (selector) => {
+      const selectorKey = selector;
+      const existing = internals.computedSelectors.get(selectorKey);
+      if (existing) return existing;
+      const initial = selector(getSnapshot(internals.signalMap));
+      const sig = core.signal(initial);
+      internals.computedSelectors.set(selectorKey, sig);
+      internals.subscribers.add(() => {
+        const newValue = selector(getSnapshot(internals.signalMap));
+        if (sig.value !== newValue) sig.value = newValue;
+      });
+      return sig;
+    }
+  };
+  const storeProxy = new Proxy(store, {
+    get(target, prop) {
+      const propStr = String(prop);
+      if (propStr === "toJSON") return () => getSnapshot(internals.signalMap);
+      if (propStr in target) return target[propStr];
+      const sig = internals.signalMap.get(propStr);
+      if (sig) return sig;
+      if (propStr in boundActions) return boundActions[propStr];
+      return void 0;
+    }
+  });
+  registerStore(name, storeProxy);
+  return storeProxy;
+};
+
+// src/context/scope.ts
+var ROOT_SCOPE = {
+  id: "__root__",
+  parent: null,
+  stores: /* @__PURE__ */ new Map()
+};
+var currentScope = ROOT_SCOPE;
+var scopeRegistry = /* @__PURE__ */ new Map([
+  [ROOT_SCOPE.id, ROOT_SCOPE]
+]);
+var scopeCounter = 0;
+var createScope = (parentScope) => {
+  scopeCounter++;
+  const id = `scope_${String(scopeCounter)}`;
+  const node = {
+    id,
+    parent: parentScope ?? currentScope,
+    stores: /* @__PURE__ */ new Map()
+  };
+  scopeRegistry.set(id, node);
+  return node;
+};
+var disposeScope = (scope) => {
+  scope.stores.clear();
+  scopeRegistry.delete(scope.id);
+};
+var enterScope = (scope) => {
+  currentScope = scope;
+};
+var exitScope = () => {
+  if (currentScope.parent) {
+    currentScope = currentScope.parent;
+  }
+};
+var getCurrentScope = () => currentScope;
+var getRootScope = () => ROOT_SCOPE;
+var registerScopedStore = (name, store, scope = currentScope) => {
+  scope.stores.set(name, store);
+};
+var getScopedStore = (name, scope = currentScope) => {
+  let current = scope;
+  while (current) {
+    const store = current.stores.get(name);
+    if (store) return store;
+    current = current.parent;
+  }
+  return null;
+};
+var hasScopedStore = (name, scope = currentScope) => {
+  return getScopedStore(name, scope) !== null;
+};
+var runInScope = (scope, fn) => {
+  const prev = currentScope;
+  currentScope = scope;
+  try {
+    return fn();
+  } finally {
+    currentScope = prev;
+  }
+};
+var withScope = (fn) => {
+  const scope = createScope();
+  try {
+    return runInScope(scope, () => fn(scope));
+  } finally {
+    disposeScope(scope);
+  }
+};
+var createAsyncAction = (fn) => {
+  let pending = false;
+  const action = async (...args) => {
+    pending = true;
+    const result = await effect.Effect.runPromise(
+      effect.Effect.tryPromise({
+        try: async () => fn(...args),
+        catch: (error) => error
+      }).pipe(
+        effect.Effect.tapBoth({
+          onSuccess: () => effect.Effect.sync(() => {
+            pending = false;
+          }),
+          onFailure: () => effect.Effect.sync(() => {
+            pending = false;
+          })
+        })
+      )
+    );
+    return result;
+  };
+  Object.defineProperty(action, "pending", {
+    get: () => pending,
+    enumerable: true
+  });
+  return action;
+};
+var createCancellableAction = (fn) => {
+  let pending = false;
+  let currentController = null;
+  const action = async (...args) => {
+    if (currentController) {
+      currentController.abort();
+    }
+    currentController = new AbortController();
+    const signal5 = currentController.signal;
+    pending = true;
+    try {
+      const effect$1 = effect.Effect.tryPromise({
+        try: async () => fn(...args),
+        catch: (error) => error
+      });
+      const result = await effect.Effect.runPromise(
+        runWithAbortSignal(effect$1, signal5)
+      );
+      return result;
+    } finally {
+      pending = false;
+      currentController = null;
+    }
+  };
+  Object.defineProperty(action, "pending", {
+    get: () => pending,
+    enumerable: true
+  });
+  Object.defineProperty(action, "cancel", {
+    value: () => {
+      if (currentController) {
+        currentController.abort();
+        currentController = null;
+        pending = false;
+      }
+    },
+    enumerable: true
+  });
+  return action;
+};
+var withTimeout = (fn, timeoutMs) => {
+  return async (...args) => {
+    const effect$1 = effect.Effect.tryPromise({
+      try: async () => fn(...args),
+      catch: (error) => error
+    }).pipe(
+      effect.Effect.timeoutFail({
+        duration: effect.Duration.millis(timeoutMs),
+        onTimeout: () => new TimeoutError({ ms: timeoutMs })
+      })
+    );
+    return effect.Effect.runPromise(effect$1);
+  };
+};
+var withRetry = (fn, config) => {
+  const {
+    maxRetries,
+    initialDelayMs = DEFAULT_RETRY_INITIAL_DELAY_MS,
+    maxDelayMs = DEFAULT_RETRY_MAX_DELAY_MS,
+    backoffFactor = DEFAULT_RETRY_BACKOFF_FACTOR
+  } = config;
+  return async (...args) => {
+    const schedule = effect.Schedule.exponential(
+      effect.Duration.millis(initialDelayMs),
+      backoffFactor
+    ).pipe(
+      effect.Schedule.either(effect.Schedule.recurs(maxRetries)),
+      effect.Schedule.upTo(effect.Duration.millis(maxDelayMs))
+    );
+    const effect$1 = effect.Effect.tryPromise({
+      try: async () => fn(...args),
+      catch: (error) => error
+    }).pipe(effect.Effect.retry(schedule));
+    return effect.Effect.runPromise(effect$1);
+  };
+};
+var takeLatest = (fn) => {
+  let pending = false;
+  let currentToken = createCancellationToken();
+  let callId = 0;
+  const action = async (...args) => {
+    currentToken.cancel();
+    currentToken = createCancellationToken();
+    const myToken = currentToken;
+    const myCallId = ++callId;
+    pending = true;
+    try {
+      const result = await fn(...args);
+      if (myToken.isCancelled || myCallId !== callId) {
+        throw new CancellationError({ message: "Superseded by newer call" });
+      }
+      return result;
+    } finally {
+      if (myCallId === callId) {
+        pending = false;
+      }
+    }
+  };
+  Object.defineProperty(action, "pending", {
+    get: () => pending,
+    enumerable: true
+  });
+  Object.defineProperty(action, "cancel", {
+    value: () => {
+      currentToken.cancel();
+      pending = false;
+    },
+    enumerable: true
+  });
+  return action;
+};
+var takeFirst = (fn) => {
+  let pending = false;
+  const action = async (...args) => {
+    if (pending) {
+      return void 0;
+    }
+    pending = true;
+    try {
+      return await fn(...args);
+    } finally {
+      pending = false;
+    }
+  };
+  Object.defineProperty(action, "pending", {
+    get: () => pending,
+    enumerable: true
+  });
+  return action;
+};
+var debounceAction = (fn, delayMs) => {
+  let timeout = null;
+  let currentToken = createCancellationToken();
+  return (...args) => {
+    if (timeout) {
+      clearTimeout(timeout);
+      currentToken.cancel();
+    }
+    currentToken = createCancellationToken();
+    const myToken = currentToken;
+    return new Promise((resolve, reject) => {
+      timeout = setTimeout(() => {
+        if (myToken.isCancelled) return;
+        Promise.resolve(fn(...args)).then((result) => {
+          if (!myToken.isCancelled) resolve(result);
+        }).catch((error) => {
+          if (!myToken.isCancelled) reject(error);
+        });
+      }, delayMs);
+    });
+  };
+};
+var throttleAction = (fn, intervalMs) => {
+  let lastCallTime = 0;
+  let pending = false;
+  return async (...args) => {
+    const now = Date.now();
+    if (now - lastCallTime < intervalMs || pending) {
+      return void 0;
+    }
+    lastCallTime = now;
+    pending = true;
+    try {
+      return await fn(...args);
+    } finally {
+      pending = false;
+    }
+  };
+};
+var dispatch = (store, actionName, ...args) => {
+  const storeRecord = store;
+  const action = storeRecord[actionName];
+  if (typeof action !== "function") {
+    return Promise.reject(
+      new ActionNotFoundError({ actionName: String(actionName) })
+    );
+  }
+  const actionFn = action;
+  return effect.Effect.runPromise(
+    effect.Effect.tryPromise({
+      try: () => Promise.resolve(actionFn(...args)),
+      catch: (error) => error
+    })
+  );
+};
+var dispatchSync = (store, actionName, ...args) => {
+  const storeRecord = store;
+  const action = storeRecord[actionName];
+  if (typeof action !== "function") {
+    throw new ActionNotFoundError({ actionName: String(actionName) });
+  }
+  const actionFn = action;
+  return actionFn(...args);
+};
+var withAbortSignal = (fn) => {
+  return (signal5, ...args) => {
+    const effect$1 = effect.Effect.tryPromise({
+      try: async () => fn(...args),
+      catch: (error) => error
+    });
+    return effect.Effect.runPromise(runWithAbortSignal(effect$1, signal5));
+  };
+};
+var validateState = (schema, state) => {
+  const result = effect.Effect.runSync(
+    effect.Schema.decodeUnknown(schema)(state).pipe(
+      effect.Effect.map((data) => ({
+        success: true,
+        data,
+        errors: []
+      })),
+      effect.Effect.catchAll(
+        (error) => effect.Effect.succeed({
+          success: false,
+          data: null,
+          errors: [String(error)]
+        })
+      )
+    )
+  );
+  return result;
+};
+var validateStateAsync = (schema, state, timeoutMs = DEFAULT_TIMEOUT_MS) => {
+  return effect.Effect.runPromise(
+    effect.Schema.decodeUnknown(schema)(state).pipe(
+      effect.Effect.map((data) => ({
+        success: true,
+        data,
+        errors: []
+      })),
+      effect.Effect.timeoutFail({
+        duration: effect.Duration.millis(timeoutMs),
+        onTimeout: () => new TimeoutError({ ms: timeoutMs })
+      }),
+      effect.Effect.catchAll(
+        (error) => effect.Effect.succeed({
+          success: false,
+          data: null,
+          errors: [
+            error instanceof TimeoutError ? `Validation timed out after ${String(timeoutMs)}ms` : String(error)
+          ]
+        })
+      )
+    )
+  );
+};
+var createValidatedSetter = (schema, onValid, onInvalid) => {
+  return (state) => {
+    const result = validateState(schema, state);
+    if (result.success && result.data) {
+      onValid(result.data);
+      return true;
+    }
+    if (effect.Predicate.isNotNullable(onInvalid)) {
+      onInvalid(result.errors);
+    }
+    return false;
+  };
+};
+var createFieldValidator = (schema) => {
+  return (value) => {
+    return effect.Effect.runSync(effect.Schema.decodeUnknown(schema)(value));
+  };
+};
+var createSafeFieldSetter = (schema, setter) => {
+  return (value) => {
+    const result = effect.Effect.runSync(
+      effect.Schema.decodeUnknown(schema)(value).pipe(
+        effect.Effect.map((decoded) => {
+          setter(decoded);
+          return true;
+        }),
+        effect.Effect.catchAll(() => effect.Effect.succeed(false))
+      )
+    );
+    return result;
+  };
+};
+var composeStores = (mainStore, dependencies) => {
+  const getDependencySnapshots = () => {
+    return dependencies.map((dep) => dep.getSnapshot());
+  };
+  return {
+    store: mainStore,
+    dependencies,
+    computed: (selector) => {
+      const mainSnapshot = mainStore.getSnapshot();
+      const depSnapshots = getDependencySnapshots();
+      const initialValue = selector(mainSnapshot, depSnapshots);
+      const derived = core.signal(initialValue);
+      const update = () => {
+        const mainState = mainStore.getSnapshot();
+        const depStates = getDependencySnapshots();
+        const newValue = selector(mainState, depStates);
+        if (derived.value !== newValue) {
+          derived.value = newValue;
+        }
+      };
+      mainStore.subscribe(update);
+      for (const dep of dependencies) {
+        dep.subscribe(update);
+      }
+      return derived;
+    },
+    computedAsync: (asyncSelector, initialValue) => {
+      const derived = core.signal(initialValue);
+      const pending = core.signal(false);
+      let currentToken = createCancellationToken();
+      const unsubscribers = [];
+      const update = () => {
+        currentToken.cancel();
+        currentToken = createCancellationToken();
+        const myToken = currentToken;
+        pending.value = true;
+        const mainState = mainStore.getSnapshot();
+        const depStates = getDependencySnapshots();
+        asyncSelector(mainState, depStates, myToken).then((newValue) => {
+          if (!myToken.isCancelled && derived.value !== newValue) {
+            derived.value = newValue;
+          }
+        }).catch(() => {
+        }).finally(() => {
+          if (!myToken.isCancelled) {
+            pending.value = false;
+          }
+        });
+      };
+      unsubscribers.push(mainStore.subscribe(update));
+      for (const dep of dependencies) {
+        unsubscribers.push(dep.subscribe(update));
+      }
+      update();
+      const result = derived;
+      result.pending = pending;
+      result.cleanup = () => {
+        currentToken.cancel();
+        for (const unsub of unsubscribers) unsub();
+      };
+      return result;
+    }
+  };
+};
+var defineSlice = (name, factory) => {
+  return {
+    create: (parent) => {
+      const definition = factory(parent);
+      return createStore(name, definition);
+    }
+  };
+};
+var mergeStores = (storeA, storeB) => {
+  return {
+    getSnapshot: () => ({
+      ...storeA.getSnapshot(),
+      ...storeB.getSnapshot()
+    }),
+    subscribe: (callback) => {
+      const unsubA = storeA.subscribe(callback);
+      const unsubB = storeB.subscribe(callback);
+      return () => {
+        unsubA();
+        unsubB();
+      };
+    }
+  };
+};
+var deriveFrom = (stores2, selector) => {
+  const getSnapshots = () => stores2.map((s) => s.getSnapshot());
+  const initialValue = selector(...getSnapshots());
+  const derivedSignal = core.signal(initialValue);
+  const update = () => {
+    const newValue = selector(...getSnapshots());
+    if (derivedSignal.value !== newValue) {
+      derivedSignal.value = newValue;
+    }
+  };
+  const unsubscribers = stores2.map((store) => store.subscribe(update));
+  const signalWithCleanup = derivedSignal;
+  signalWithCleanup.cleanup = () => {
+    for (const unsub of unsubscribers) {
+      unsub();
+    }
+  };
+  return signalWithCleanup;
+};
+var deriveFromAsync = (stores2, asyncSelector, initialValue) => {
+  const getSnapshots = () => stores2.map((s) => s.getSnapshot());
+  const derivedSignal = core.signal(initialValue);
+  const pendingSignal = core.signal(false);
+  let currentToken = createCancellationToken();
+  const update = () => {
+    currentToken.cancel();
+    currentToken = createCancellationToken();
+    const myToken = currentToken;
+    pendingSignal.value = true;
+    asyncSelector(getSnapshots(), myToken).then((newValue) => {
+      if (!myToken.isCancelled && derivedSignal.value !== newValue) {
+        derivedSignal.value = newValue;
+      }
+    }).catch(() => {
+    }).finally(() => {
+      if (!myToken.isCancelled) {
+        pendingSignal.value = false;
+      }
+    });
+  };
+  const unsubscribers = stores2.map((store) => store.subscribe(update));
+  update();
+  const signalWithCleanup = derivedSignal;
+  signalWithCleanup.cleanup = () => {
+    currentToken.cancel();
+    for (const unsub of unsubscribers) {
+      unsub();
+    }
+  };
+  signalWithCleanup.pending = pendingSignal;
+  return signalWithCleanup;
+};
+var serializeStores = () => {
+  const storeNames = getStoreNames();
+  const allSnapshots = {};
+  for (const name of storeNames) {
+    const store = getStore(name);
+    allSnapshots[name] = store.getSnapshot();
+  }
+  return JSON.stringify(allSnapshots);
+};
+var hydrateStores = (serialized) => effect.Effect.try({
+  try: () => {
+    const allSnapshots = JSON.parse(serialized);
+    for (const [name, snapshot] of Object.entries(allSnapshots)) {
+      effect.Effect.runSync(
+        effect.Effect.try(() => {
+          const store = getStore(name);
+          store.update((draft) => {
+            Object.assign(draft, snapshot);
+          });
+        }).pipe(effect.Effect.catchAll(() => effect.Effect.void))
+      );
+    }
+  },
+  catch: () => new HydrationError({})
+}).pipe(effect.Effect.catchAll(() => effect.Effect.void));
+var hydrateStoresSync = (serialized) => {
+  effect.Effect.runSync(
+    hydrateStores(serialized).pipe(
+      effect.Effect.match({
+        onSuccess: () => effect.Option.some(void 0),
+        onFailure: () => effect.Option.none()
+      })
+    )
+  );
+};
+
+// src/reactivity/streams.ts
+var createBaseStream = (addListener) => {
+  return {
+    subscribe: addListener,
+    map: (fn) => {
+      const mappedListeners = /* @__PURE__ */ new Set();
+      addListener((value) => {
+        const mapped = fn(value);
+        for (const h of mappedListeners) h(mapped);
+      });
+      return createBaseStream((h) => {
+        mappedListeners.add(h);
+        return () => mappedListeners.delete(h);
+      });
+    },
+    filter: (predicate) => {
+      const filteredListeners = /* @__PURE__ */ new Set();
+      addListener((value) => {
+        if (predicate(value)) {
+          for (const h of filteredListeners) h(value);
+        }
+      });
+      return createBaseStream((h) => {
+        filteredListeners.add(h);
+        return () => filteredListeners.delete(h);
+      });
+    },
+    debounce: (ms) => {
+      const debouncedListeners = /* @__PURE__ */ new Set();
+      let timeout = null;
+      let latestValue;
+      let currentToken = createCancellationToken();
+      addListener((value) => {
+        latestValue = value;
+        if (timeout) {
+          clearTimeout(timeout);
+          currentToken.cancel();
+        }
+        currentToken = createCancellationToken();
+        const myToken = currentToken;
+        timeout = setTimeout(() => {
+          if (!myToken.isCancelled && latestValue !== void 0) {
+            for (const h of debouncedListeners) h(latestValue);
+          }
+        }, ms);
+      });
+      return createBaseStream((h) => {
+        debouncedListeners.add(h);
+        return () => debouncedListeners.delete(h);
+      });
+    },
+    throttle: (ms) => {
+      const throttledListeners = /* @__PURE__ */ new Set();
+      let lastEmitTime = 0;
+      addListener((value) => {
+        const now = Date.now();
+        if (now - lastEmitTime >= ms) {
+          lastEmitTime = now;
+          for (const h of throttledListeners) h(value);
+        }
+      });
+      return createBaseStream((h) => {
+        throttledListeners.add(h);
+        return () => throttledListeners.delete(h);
+      });
+    },
+    takeLatest: (asyncHandler) => {
+      const latestListeners = /* @__PURE__ */ new Set();
+      let currentToken = createCancellationToken();
+      addListener((value) => {
+        currentToken.cancel();
+        currentToken = createCancellationToken();
+        const myToken = currentToken;
+        asyncHandler(value, myToken).then((result) => {
+          if (!myToken.isCancelled) {
+            for (const h of latestListeners) h(result);
+          }
+        }).catch(() => {
+        });
+      });
+      return createBaseStream((h) => {
+        latestListeners.add(h);
+        return () => latestListeners.delete(h);
+      });
+    }
+  };
+};
+var createStoreStream = (store, key) => {
+  const listeners = /* @__PURE__ */ new Set();
+  let lastValue = store.getSnapshot()[key];
+  store.subscribe(() => {
+    const snapshot = store.getSnapshot();
+    const newValue = snapshot[key];
+    if (newValue !== lastValue) {
+      lastValue = newValue;
+      for (const listener of listeners) {
+        listener(newValue);
+      }
+    }
+  });
+  return createBaseStream((handler) => {
+    listeners.add(handler);
+    return () => listeners.delete(handler);
+  });
+};
+var streamAll = (store) => {
+  const listeners = /* @__PURE__ */ new Set();
+  store.subscribe(() => {
+    const snapshot = store.getSnapshot();
+    for (const listener of listeners) {
+      listener(snapshot);
+    }
+  });
+  return createBaseStream((handler) => {
+    listeners.add(handler);
+    return () => listeners.delete(handler);
+  });
+};
+var shallowEqual = (a, b) => {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) {
+    return false;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      if (!Object.is(a[i], b[i])) return false;
+    }
+    return true;
+  }
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+  if (keysA.length !== keysB.length) return false;
+  for (const key of keysA) {
+    if (!Object.prototype.hasOwnProperty.call(b, key)) return false;
+    if (!Object.is(
+      a[key],
+      b[key]
+    )) {
+      return false;
+    }
+  }
+  return true;
+};
+var createSelector = (store, selector, equalityFn = shallowEqual) => {
+  const snapshot = store.getSnapshot();
+  const initialValue = selector(snapshot);
+  const derived = core.signal(initialValue);
+  store.subscribe(() => {
+    const currentSnapshot = store.getSnapshot();
+    const newValue = selector(currentSnapshot);
+    if (!equalityFn(derived.value, newValue)) {
+      derived.value = newValue;
+    }
+  });
+  return derived;
+};
+var createSelectorAsync = (store, asyncSelector, initialValue) => {
+  const derived = core.signal(initialValue);
+  const pending = core.signal(false);
+  let currentToken = createCancellationToken();
+  const update = () => {
+    currentToken.cancel();
+    currentToken = createCancellationToken();
+    const myToken = currentToken;
+    pending.value = true;
+    const snapshot = store.getSnapshot();
+    asyncSelector(snapshot, myToken).then((newValue) => {
+      if (!myToken.isCancelled && derived.value !== newValue) {
+        derived.value = newValue;
+      }
+    }).catch(() => {
+    }).finally(() => {
+      if (!myToken.isCancelled) {
+        pending.value = false;
+      }
+    });
+  };
+  const unsub = store.subscribe(update);
+  update();
+  const result = derived;
+  result.pending = pending;
+  result.cleanup = () => {
+    currentToken.cancel();
+    unsub();
+  };
+  return result;
+};
+var pick = (store, keys) => {
+  return createSelector(store, (state) => {
+    const picked = {};
+    for (const key of keys) {
+      if (key in state) {
+        picked[key] = state[key];
+      }
+    }
+    return picked;
+  });
+};
+var combineSelectors = (store, selectors) => {
+  return createSelector(store, (state) => {
+    const result = {};
+    for (const key of Object.keys(selectors)) {
+      result[key] = selectors[key](state);
+    }
+    return result;
+  });
+};
+var hasDevTools = () => {
+  if (typeof globalThis === "undefined") return false;
+  const w = globalThis;
+  return w.__REDUX_DEVTOOLS_EXTENSION__ !== void 0;
+};
+var connections = /* @__PURE__ */ new Map();
+var connectDevTools = (store, options) => {
+  if (!hasDevTools()) {
+    return () => {
+    };
+  }
+  const w = globalThis;
+  const extension = w.__REDUX_DEVTOOLS_EXTENSION__;
+  if (!extension) return () => {
+  };
+  const storeName = effect.pipe(
+    effect.Option.fromNullable(options),
+    effect.Option.flatMap((o) => effect.Option.fromNullable(o.name)),
+    effect.Option.getOrElse(() => store.name)
+  );
+  if (connections.has(storeName)) {
+    return () => {
+    };
+  }
+  const devTools = extension.connect({ name: `Effuse: ${storeName}` });
+  connections.set(storeName, devTools);
+  devTools.init(store.getSnapshot());
+  const unsubscribe = store.subscribe(() => {
+    devTools.send({ type: `${storeName}/update` }, store.getSnapshot());
+  });
+  return () => {
+    unsubscribe();
+    connections.delete(storeName);
+  };
+};
+var devToolsMiddleware = (storeName) => {
+  return (state, action, args) => {
+    const connection = connections.get(storeName);
+    if (connection) {
+      connection.send(
+        { type: action, payload: args.length === 1 ? args[0] : args },
+        state
+      );
+    }
+    return void 0;
+  };
+};
+var createDevToolsMiddleware = (storeName) => devToolsMiddleware(storeName);
+var disconnectDevTools = (storeName) => {
+  connections.delete(storeName);
+};
+var disconnectAllDevTools = () => {
+  connections.clear();
+};
+
+exports.ActionNotFoundError = ActionNotFoundError;
+exports.CancellationError = CancellationError;
+exports.DEFAULT_RETRY_BACKOFF_FACTOR = DEFAULT_RETRY_BACKOFF_FACTOR;
+exports.DEFAULT_RETRY_INITIAL_DELAY_MS = DEFAULT_RETRY_INITIAL_DELAY_MS;
+exports.DEFAULT_RETRY_MAX_DELAY_MS = DEFAULT_RETRY_MAX_DELAY_MS;
+exports.DEFAULT_TIMEOUT_MS = DEFAULT_TIMEOUT_MS;
+exports.ROOT_SCOPE_ID = ROOT_SCOPE_ID;
+exports.SCOPE_PREFIX = SCOPE_PREFIX;
+exports.STORAGE_PREFIX = STORAGE_PREFIX;
+exports.StoreAlreadyExistsError = StoreAlreadyExistsError;
+exports.StoreConstants = StoreConstants;
+exports.StoreNotFoundError = StoreNotFoundError;
+exports.TimeoutError = TimeoutError;
+exports.ValidationError = ValidationError;
+exports.clearStores = clearStores;
+exports.combineSelectors = combineSelectors;
+exports.composeStores = composeStores;
+exports.connectDevTools = connectDevTools;
+exports.createAsyncAction = createAsyncAction;
+exports.createAtomicState = createAtomicState;
+exports.createCancellableAction = createCancellableAction;
+exports.createCancellationScope = createCancellationScope;
+exports.createCancellationToken = createCancellationToken;
+exports.createDevToolsMiddleware = createDevToolsMiddleware;
+exports.createFieldValidator = createFieldValidator;
+exports.createMiddlewareManager = createMiddlewareManager;
+exports.createSafeFieldSetter = createSafeFieldSetter;
+exports.createScope = createScope;
+exports.createSelector = createSelector;
+exports.createSelectorAsync = createSelectorAsync;
+exports.createStore = createStore;
+exports.createStoreStream = createStoreStream;
+exports.createValidatedSetter = createValidatedSetter;
+exports.debounceAction = debounceAction;
+exports.defineSlice = defineSlice;
+exports.deriveFrom = deriveFrom;
+exports.deriveFromAsync = deriveFromAsync;
+exports.devToolsMiddleware = devToolsMiddleware;
+exports.disconnectAllDevTools = disconnectAllDevTools;
+exports.disconnectDevTools = disconnectDevTools;
+exports.dispatch = dispatch;
+exports.dispatchSync = dispatchSync;
+exports.disposeScope = disposeScope;
+exports.enterScope = enterScope;
+exports.exitScope = exitScope;
+exports.getCurrentScope = getCurrentScope;
+exports.getRootScope = getRootScope;
+exports.getScopedStore = getScopedStore;
+exports.getStore = getStore;
+exports.getStoreConfig = getStoreConfig;
+exports.getStoreNames = getStoreNames;
+exports.hasDevTools = hasDevTools;
+exports.hasScopedStore = hasScopedStore;
+exports.hasStore = hasStore;
+exports.hydrateStoresSync = hydrateStoresSync;
+exports.mergeStores = mergeStores;
+exports.pick = pick;
+exports.registerScopedStore = registerScopedStore;
+exports.removeStore = removeStore;
+exports.resetStoreConfigCache = resetStoreConfigCache;
+exports.runInScope = runInScope;
+exports.serializeStores = serializeStores;
+exports.shallowEqual = shallowEqual;
+exports.streamAll = streamAll;
+exports.takeFirst = takeFirst;
+exports.takeLatest = takeLatest;
+exports.throttleAction = throttleAction;
+exports.validateState = validateState;
+exports.validateStateAsync = validateStateAsync;
+exports.withAbortSignal = withAbortSignal;
+exports.withRetry = withRetry;
+exports.withScope = withScope;
+exports.withTimeout = withTimeout;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map