gjendje 0.1.0

package/dist/chunk-GGB5QBDR.cjs

@@ -0,0 +1,1136 @@
+'use strict';
+
+var async_hooks = require('async_hooks');
+
+// src/adapters/server.ts
+
+// src/batch.ts
+var depth = 0;
+var queue = /* @__PURE__ */ new Set();
+function batch(fn) {
+  depth++;
+  try {
+    fn();
+  } finally {
+    depth--;
+    if (depth === 0) flush();
+  }
+}
+function notify(fn) {
+  if (depth > 0) {
+    queue.add(fn);
+    return;
+  }
+  fn();
+}
+function flush() {
+  while (queue.size > 0) {
+    const pending = new Set(queue);
+    queue.clear();
+    depth++;
+    try {
+      for (const notification of pending) {
+        notification();
+      }
+    } finally {
+      depth--;
+    }
+  }
+}
+
+// src/adapters/server.ts
+var als = new async_hooks.AsyncLocalStorage();
+async function withServerSession(fn) {
+  const store = /* @__PURE__ */ new Map();
+  return als.run(store, fn);
+}
+function createServerAdapter(key, defaultValue) {
+  const listeners = /* @__PURE__ */ new Set();
+  function getStore() {
+    return als.getStore();
+  }
+  let lastNotifiedValue = defaultValue;
+  const notifyListeners = () => {
+    for (const listener of listeners) {
+      listener(lastNotifiedValue);
+    }
+  };
+  return {
+    ready: Promise.resolve(),
+    get() {
+      const store = getStore();
+      if (!store) return defaultValue;
+      return store.has(key) ? store.get(key) : defaultValue;
+    },
+    set(value) {
+      const store = getStore();
+      if (!store) {
+        throw new Error(
+          "[state] Cannot set server-scoped state outside of a server session. Wrap your request handler with withServerSession()."
+        );
+      }
+      store.set(key, value);
+      lastNotifiedValue = value;
+      notify(notifyListeners);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    destroy() {
+      listeners.clear();
+    }
+  };
+}
+
+// src/config.ts
+var globalConfig = {};
+function configure(config) {
+  globalConfig = { ...globalConfig, ...config };
+}
+function getConfig() {
+  return globalConfig;
+}
+function log(level, message) {
+  const configLevel = globalConfig.logLevel ?? "warn";
+  if (configLevel === "silent") return;
+  const priority = { debug: 0, warn: 1, error: 2 };
+  if (priority[level] >= priority[configLevel]) {
+    console[level](`[stead] ${message}`);
+  }
+}
+function reportError(key, scope, error) {
+  globalConfig.onError?.({ key, scope, error });
+}
+
+// src/persist.ts
+function readAndMigrate(raw, options, key, scope) {
+  const currentVersion = options.version ?? 1;
+  const defaultValue = options.default;
+  try {
+    let isVersionedValue2 = function(value) {
+      const hasShape = value !== null && typeof value === "object" && "v" in value && "data" in value;
+      return hasShape && typeof value.v === "number";
+    };
+    var isVersionedValue = isVersionedValue2;
+    const parsed = JSON.parse(raw);
+    let storedVersion = 1;
+    let data;
+    if (isVersionedValue2(parsed)) {
+      storedVersion = parsed.v;
+      data = parsed.data;
+    } else {
+      storedVersion = 1;
+      data = parsed;
+    }
+    if (storedVersion < currentVersion && options.migrate) {
+      data = runMigrations(data, storedVersion, currentVersion, options.migrate);
+      if (key && scope) {
+        getConfig().onMigrate?.({
+          key,
+          scope,
+          fromVersion: storedVersion,
+          toVersion: currentVersion,
+          data
+        });
+      }
+    }
+    if (options.validate && !options.validate(data)) {
+      return defaultValue;
+    }
+    return data;
+  } catch {
+    log("debug", `Failed to read/migrate stored value \u2014 falling back to default.`);
+    return defaultValue;
+  }
+}
+function wrapForStorage(value, version) {
+  if (!version || version === 1) {
+    return JSON.stringify(value);
+  }
+  const envelope = { v: version, data: value };
+  return JSON.stringify(envelope);
+}
+function pickKeys(value, keys) {
+  if (!keys || typeof value !== "object" || value === null) return value;
+  const partial = {};
+  for (const k of keys) {
+    if (k in value) {
+      partial[k] = value[k];
+    }
+  }
+  return partial;
+}
+function mergeKeys(stored, defaultValue, keys) {
+  if (!keys || typeof stored !== "object" || stored === null) return stored;
+  return { ...defaultValue, ...stored };
+}
+function runMigrations(data, fromVersion, toVersion, migrations) {
+  let current = data;
+  for (let v = fromVersion; v < toVersion; v++) {
+    const migrateFn = migrations[v];
+    if (migrateFn) {
+      try {
+        current = migrateFn(current);
+      } catch {
+        log("warn", `Migration from v${v} failed \u2014 returning partially migrated value.`);
+        return current;
+      }
+    }
+  }
+  return current;
+}
+
+// src/adapters/storage.ts
+function createStorageAdapter(storage, key, options) {
+  const { default: defaultValue, version, serialize, persist } = options;
+  const listeners = /* @__PURE__ */ new Set();
+  function read() {
+    try {
+      const raw = storage.getItem(key);
+      if (raw === null) return defaultValue;
+      let value;
+      if (serialize) {
+        try {
+          value = serialize.parse(raw);
+        } catch {
+          return defaultValue;
+        }
+      } else {
+        value = readAndMigrate(raw, options, key, options.scope);
+      }
+      return mergeKeys(value, defaultValue, persist);
+    } catch {
+      return defaultValue;
+    }
+  }
+  function write(value) {
+    try {
+      const toStore = pickKeys(value, persist);
+      const raw = serialize ? serialize.stringify(toStore) : wrapForStorage(toStore, version);
+      storage.setItem(key, raw);
+    } catch (e) {
+      log(
+        "error",
+        `Failed to write key "${key}" to storage: ${e instanceof Error ? e.message : String(e)}`
+      );
+      const isQuotaError = e instanceof DOMException && (e.name === "QuotaExceededError" || e.code === 22);
+      if (isQuotaError && options.scope) {
+        getConfig().onQuotaExceeded?.({ key, scope: options.scope, error: e });
+      }
+    }
+  }
+  let lastNotifiedValue = defaultValue;
+  const notifyListeners = () => {
+    for (const listener of listeners) {
+      listener(lastNotifiedValue);
+    }
+  };
+  function onStorageEvent(event) {
+    if (event.storageArea !== storage || event.key !== key) return;
+    lastNotifiedValue = read();
+    notify(notifyListeners);
+  }
+  if (typeof window !== "undefined") {
+    window.addEventListener("storage", onStorageEvent);
+  }
+  return {
+    ready: Promise.resolve(),
+    get() {
+      return read();
+    },
+    set(value) {
+      write(value);
+      lastNotifiedValue = value;
+      notify(notifyListeners);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    destroy() {
+      listeners.clear();
+      if (typeof window !== "undefined") {
+        window.removeEventListener("storage", onStorageEvent);
+      }
+    }
+  };
+}
+
+// src/adapters/bucket.ts
+function isBucketSupported() {
+  return typeof navigator !== "undefined" && "storageBuckets" in navigator && navigator.storageBuckets != null;
+}
+function parseExpiry(expires) {
+  if (typeof expires === "number") return expires;
+  const units = {
+    ms: 1,
+    s: 1e3,
+    m: 6e4,
+    h: 36e5,
+    d: 864e5,
+    w: 6048e5
+  };
+  const match = expires.match(/^(\d+(?:\.\d+)?)(ms|s|m|h|d|w)$/);
+  if (!match || !match[1] || !match[2]) return void 0;
+  const value = parseFloat(match[1]);
+  const unit = units[match[2]];
+  if (!unit) return void 0;
+  return Date.now() + value * unit;
+}
+function parseQuota(quota) {
+  if (typeof quota === "number") return quota;
+  const units = {
+    b: 1,
+    kb: 1024,
+    mb: 1048576,
+    gb: 1073741824
+  };
+  const match = quota.toLowerCase().match(/^(\d+(?:\.\d+)?)(b|kb|mb|gb)$/);
+  if (!match || !match[1] || !match[2]) return void 0;
+  const value = parseFloat(match[1]);
+  const unit = units[match[2]];
+  if (!unit) return void 0;
+  return Math.floor(value * unit);
+}
+function createBucketAdapter(key, bucketOptions, options) {
+  const { default: defaultValue } = options;
+  const fallbackScope = bucketOptions.fallback ?? "local";
+  const listeners = /* @__PURE__ */ new Set();
+  let lastNotifiedValue = defaultValue;
+  const notifyListeners = () => {
+    for (const listener of listeners) {
+      listener(lastNotifiedValue);
+    }
+  };
+  let delegate = null;
+  let isDestroyed = false;
+  function read() {
+    if (!delegate) return defaultValue;
+    return delegate.get();
+  }
+  function write(value) {
+    if (!delegate) return;
+    delegate.set(value);
+  }
+  const ready = (async () => {
+    try {
+      if (!isBucketSupported()) {
+        throw new Error("Storage Buckets not supported");
+      }
+      const openOptions = {
+        persisted: bucketOptions.persisted ?? false,
+        durability: "strict"
+      };
+      if (bucketOptions.expires != null) {
+        const parsed = parseExpiry(bucketOptions.expires);
+        if (parsed != null) {
+          openOptions.expires = parsed;
+        } else {
+          console.warn(
+            `[state] Invalid bucket expires format: "${bucketOptions.expires}". Expected a number or a string like "7d", "24h", "30m".`
+          );
+        }
+      }
+      if (bucketOptions.quota != null) {
+        const parsed = parseQuota(bucketOptions.quota);
+        if (parsed != null) {
+          openOptions.quota = parsed;
+        } else {
+          console.warn(
+            `[state] Invalid bucket quota format: "${bucketOptions.quota}". Expected a number or a string like "10mb", "50kb", "1gb".`
+          );
+        }
+      }
+      const bucketManager = navigator.storageBuckets;
+      if (!bucketManager) throw new Error("Storage Buckets not supported");
+      const bucket = await bucketManager.open(bucketOptions.name, openOptions);
+      const storage = await bucket.localStorage();
+      delegate = createStorageAdapter(storage, key, options);
+    } catch {
+      await Promise.resolve();
+      const fallbackStorage = fallbackScope === "tab" ? sessionStorage : localStorage;
+      delegate = createStorageAdapter(fallbackStorage, key, options);
+    }
+    if (isDestroyed) {
+      delegate?.destroy?.();
+      delegate = null;
+      return;
+    }
+    const storedValue = delegate.get();
+    if (JSON.stringify(storedValue) !== JSON.stringify(defaultValue)) {
+      lastNotifiedValue = storedValue;
+      notify(notifyListeners);
+    }
+    delegate.subscribe((value) => {
+      lastNotifiedValue = value;
+      notify(notifyListeners);
+    });
+  })();
+  return {
+    ready,
+    get() {
+      return read();
+    },
+    set(value) {
+      write(value);
+      lastNotifiedValue = value;
+      notify(notifyListeners);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    destroy() {
+      isDestroyed = true;
+      listeners.clear();
+      delegate?.destroy?.();
+      delegate = null;
+    }
+  };
+}
+
+// src/adapters/local.ts
+function createLocalAdapter(key, options) {
+  if (typeof localStorage === "undefined") {
+    throw new Error(
+      '[state] localStorage is not available. Use ssr: true or scope: "server" for server environments.'
+    );
+  }
+  return createStorageAdapter(localStorage, key, options);
+}
+
+// src/adapters/render.ts
+function createRenderAdapter(defaultValue) {
+  let current = defaultValue;
+  const listeners = /* @__PURE__ */ new Set();
+  const notifyListeners = () => {
+    for (const listener of listeners) {
+      listener(current);
+    }
+  };
+  return {
+    ready: Promise.resolve(),
+    get() {
+      return current;
+    },
+    set(value) {
+      current = value;
+      notify(notifyListeners);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    destroy() {
+      listeners.clear();
+    }
+  };
+}
+
+// src/adapters/sync.ts
+function withSync(adapter, key, scope) {
+  const channelName = `state:${key}`;
+  const channel = typeof BroadcastChannel !== "undefined" ? new BroadcastChannel(channelName) : null;
+  const listeners = /* @__PURE__ */ new Set();
+  adapter.subscribe((value) => {
+    for (const listener of listeners) {
+      listener(value);
+    }
+  });
+  if (channel) {
+    channel.onmessage = (event) => {
+      if (event.data == null || typeof event.data !== "object" || !("value" in event.data)) return;
+      const value = event.data.value;
+      adapter.set(value);
+      if (scope) {
+        getConfig().onSync?.({ key, scope, value, source: "remote" });
+      }
+    };
+  }
+  return {
+    get ready() {
+      return adapter.ready;
+    },
+    get() {
+      return adapter.get();
+    },
+    set(value) {
+      adapter.set(value);
+      channel?.postMessage({ value });
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    destroy() {
+      listeners.clear();
+      channel?.close();
+      adapter.destroy?.();
+    }
+  };
+}
+
+// src/adapters/tab.ts
+function createTabAdapter(key, options) {
+  if (typeof sessionStorage === "undefined") {
+    throw new Error(
+      '[state] sessionStorage is not available. Use ssr: true or scope: "render" for server environments.'
+    );
+  }
+  return createStorageAdapter(sessionStorage, key, options);
+}
+
+// src/adapters/url.ts
+function createUrlAdapter(key, defaultValue, serializer, persist) {
+  if (typeof window === "undefined") {
+    throw new Error("[state] URL scope is not available in this environment.");
+  }
+  const listeners = /* @__PURE__ */ new Set();
+  function read() {
+    try {
+      const params = new URLSearchParams(window.location.search);
+      const raw = params.get(key);
+      if (raw === null) return defaultValue;
+      return mergeKeys(serializer.parse(decodeURIComponent(raw)), defaultValue, persist);
+    } catch {
+      return defaultValue;
+    }
+  }
+  function write(value) {
+    const params = new URLSearchParams(window.location.search);
+    const toStore = pickKeys(value, persist);
+    const stringified = serializer.stringify(toStore);
+    const isDefault = stringified === serializer.stringify(defaultValue);
+    if (isDefault) {
+      params.delete(key);
+    } else {
+      params.set(key, encodeURIComponent(stringified));
+    }
+    const search = params.toString();
+    const newUrl = search ? `${window.location.pathname}?${search}${window.location.hash}` : `${window.location.pathname}${window.location.hash}`;
+    window.history.pushState(null, "", newUrl);
+  }
+  let lastNotifiedValue = defaultValue;
+  const notifyListeners = () => {
+    for (const listener of listeners) {
+      listener(lastNotifiedValue);
+    }
+  };
+  function onPopState() {
+    lastNotifiedValue = read();
+    notify(notifyListeners);
+  }
+  window.addEventListener("popstate", onPopState);
+  return {
+    ready: Promise.resolve(),
+    get() {
+      return read();
+    },
+    set(value) {
+      write(value);
+      lastNotifiedValue = value;
+      notify(notifyListeners);
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    destroy() {
+      listeners.clear();
+      window.removeEventListener("popstate", onPopState);
+    }
+  };
+}
+
+// src/registry.ts
+function scopedKey(key, scope) {
+  return `${scope}:${key}`;
+}
+var registry = /* @__PURE__ */ new Map();
+function getRegistered(key, scope) {
+  return registry.get(scopedKey(key, scope));
+}
+function register(key, scope, instance) {
+  const rKey = scopedKey(key, scope);
+  if (registry.has(rKey)) {
+    const existing = registry.get(rKey);
+    if (existing?.isDestroyed) {
+      registry.set(rKey, instance);
+    } else {
+      const config2 = getConfig();
+      if (config2.warnOnDuplicate) {
+        log("warn", `Duplicate state("${key}") with scope "${scope}". Returning cached instance.`);
+      }
+    }
+    return;
+  }
+  const config = getConfig();
+  if (config.maxKeys !== void 0 && registry.size >= config.maxKeys) {
+    throw new Error(
+      `[stead] maxKeys limit (${config.maxKeys}) reached. Cannot register state("${key}") with scope "${scope}".`
+    );
+  }
+  registry.set(rKey, instance);
+  config.onRegister?.({ key, scope });
+}
+function unregister(key, scope) {
+  registry.delete(scopedKey(key, scope));
+}
+
+// src/ssr.ts
+function isServer() {
+  return typeof window === "undefined" || typeof document === "undefined";
+}
+var BROWSER_SCOPES = /* @__PURE__ */ new Set(["tab", "local", "url", "bucket"]);
+function afterHydration(fn) {
+  if (isServer()) return Promise.resolve();
+  return new Promise((resolve) => {
+    Promise.resolve().then(() => {
+      if (typeof requestAnimationFrame !== "undefined") {
+        requestAnimationFrame(() => {
+          fn();
+          resolve();
+        });
+      } else {
+        setTimeout(() => {
+          fn();
+          resolve();
+        }, 0);
+      }
+    });
+  });
+}
+
+// src/core.ts
+var PERSISTENT_SCOPES = /* @__PURE__ */ new Set(["local", "tab", "bucket"]);
+var SYNCABLE_SCOPES = /* @__PURE__ */ new Set(["local", "bucket"]);
+function resolveStorageKey(key, options) {
+  if (options.prefix === false) return key;
+  const prefix = options.prefix ?? getConfig().prefix;
+  return prefix ? `${prefix}:${key}` : key;
+}
+function resolveAdapter(key, scope, options) {
+  const storageKey = resolveStorageKey(key, options);
+  switch (scope) {
+    case "render":
+      return createRenderAdapter(options.default);
+    case "tab":
+      return createTabAdapter(storageKey, options);
+    case "local":
+      return createLocalAdapter(storageKey, options);
+    case "url":
+      return createUrlAdapter(
+        storageKey,
+        options.default,
+        options.serialize ?? {
+          stringify: (v) => JSON.stringify(v),
+          parse: (s) => JSON.parse(s)
+        },
+        options.persist
+      );
+    case "server":
+      return createServerAdapter(storageKey, options.default);
+    case "bucket": {
+      if (!options.bucket) {
+        throw new Error(
+          '[state] scope: "bucket" requires a bucket option. Example: { scope: "bucket", bucket: { name: "my-bucket" } }'
+        );
+      }
+      return createBucketAdapter(storageKey, options.bucket, options);
+    }
+    default: {
+      const _exhaustive = scope;
+      throw new Error(`[state] Unknown scope: ${_exhaustive}`);
+    }
+  }
+}
+function createBase(key, options) {
+  if (!key) {
+    throw new Error("[state] key must be a non-empty string.");
+  }
+  const config = getConfig();
+  if (config.keyPattern && !config.keyPattern.test(key)) {
+    throw new Error(
+      `[stead] Key "${key}" does not match the configured keyPattern ${config.keyPattern}.`
+    );
+  }
+  const scope = options.scope ?? config.defaultScope ?? "render";
+  const existing = getRegistered(key, scope);
+  if (existing && !existing.isDestroyed) return existing;
+  if (config.requireValidation && PERSISTENT_SCOPES.has(scope) && !options.validate) {
+    throw new Error(
+      `[stead] A validate function is required for persisted scope "${scope}" on state("${key}"). Set requireValidation: false in configure() to disable.`
+    );
+  }
+  const defaultValue = options.default;
+  const isSsrMode = (options.ssr ?? config.ssr) && BROWSER_SCOPES.has(scope);
+  const useRenderFallback = isSsrMode && isServer();
+  const storageKey = resolveStorageKey(key, options);
+  const baseAdapter = useRenderFallback ? createRenderAdapter(defaultValue) : resolveAdapter(key, scope, options);
+  const effectiveSync = options.sync ?? (config.sync && SYNCABLE_SCOPES.has(scope));
+  if (effectiveSync && !SYNCABLE_SCOPES.has(scope)) {
+    log(
+      "warn",
+      `sync: true is ignored for scope "${scope}". Only "local" and "bucket" scopes support cross-tab sync.`
+    );
+  }
+  const shouldSync = effectiveSync && SYNCABLE_SCOPES.has(scope) && !useRenderFallback;
+  const adapter = shouldSync ? withSync(baseAdapter, storageKey, scope) : baseAdapter;
+  let lastValue = adapter.get();
+  let _isDestroyed = false;
+  const _interceptors = /* @__PURE__ */ new Set();
+  const _hooks = /* @__PURE__ */ new Set();
+  let _settled = Promise.resolve();
+  let _resolveDestroyed;
+  const _destroyed = new Promise((resolve) => {
+    _resolveDestroyed = resolve;
+  });
+  let _hydrated;
+  if (isSsrMode && !isServer()) {
+    _hydrated = afterHydration(() => {
+      try {
+        const realAdapter = resolveAdapter(key, scope, options);
+        const storedValue = realAdapter.get();
+        const serverValue = defaultValue;
+        const clientValue = storedValue;
+        if (JSON.stringify(storedValue) !== JSON.stringify(defaultValue)) {
+          instance.set(storedValue);
+        }
+        config.onHydrate?.({ key, scope, serverValue, clientValue });
+      } catch (err) {
+        log("debug", `Hydration adapter unavailable for state("${key}") \u2014 using render fallback.`);
+        reportError(key, scope, err);
+      }
+    });
+  } else {
+    _hydrated = Promise.resolve();
+  }
+  const instance = {
+    get() {
+      return _isDestroyed ? lastValue : adapter.get();
+    },
+    peek() {
+      return _isDestroyed ? lastValue : adapter.get();
+    },
+    set(valueOrUpdater) {
+      if (_isDestroyed) return;
+      const prev = adapter.get();
+      let next = typeof valueOrUpdater === "function" ? valueOrUpdater(prev) : valueOrUpdater;
+      for (const interceptor of _interceptors) {
+        next = interceptor(next, prev);
+      }
+      lastValue = next;
+      adapter.set(next);
+      _settled = adapter.ready;
+      for (const hook of _hooks) {
+        hook(next, prev);
+      }
+    },
+    subscribe(listener) {
+      return adapter.subscribe(listener);
+    },
+    reset() {
+      if (_isDestroyed) return;
+      const prev = adapter.get();
+      let next = defaultValue;
+      for (const interceptor of _interceptors) {
+        next = interceptor(next, prev);
+      }
+      lastValue = next;
+      adapter.set(next);
+      _settled = adapter.ready;
+      for (const hook of _hooks) {
+        hook(next, prev);
+      }
+    },
+    get ready() {
+      return adapter.ready;
+    },
+    get settled() {
+      return _settled;
+    },
+    get hydrated() {
+      return _hydrated;
+    },
+    get destroyed() {
+      return _destroyed;
+    },
+    get scope() {
+      return scope;
+    },
+    get key() {
+      return key;
+    },
+    get isDestroyed() {
+      return _isDestroyed;
+    },
+    intercept(fn) {
+      _interceptors.add(fn);
+      return () => {
+        _interceptors.delete(fn);
+      };
+    },
+    use(fn) {
+      _hooks.add(fn);
+      return () => {
+        _hooks.delete(fn);
+      };
+    },
+    destroy() {
+      if (_isDestroyed) return;
+      lastValue = adapter.get();
+      _isDestroyed = true;
+      _interceptors.clear();
+      _hooks.clear();
+      adapter.destroy?.();
+      unregister(key, scope);
+      config.onDestroy?.({ key, scope });
+      _resolveDestroyed();
+    }
+  };
+  register(key, scope, instance);
+  return instance;
+}
+
+// src/collection.ts
+function collection(key, options) {
+  const base = createBase(key, options);
+  const watchers = /* @__PURE__ */ new Map();
+  let prevItems = base.get();
+  const unsubscribe = base.subscribe((next) => {
+    if (watchers.size === 0) {
+      prevItems = next;
+      return;
+    }
+    for (const [watchKey, listeners] of watchers) {
+      const keyChanged = (prev, next2) => {
+        if (!prev || !next2 || typeof prev !== "object" || typeof next2 !== "object") {
+          return false;
+        }
+        const p = prev;
+        const n = next2;
+        return !Object.is(p[watchKey], n[watchKey]);
+      };
+      const changed = next.length !== prevItems.length || next.some((item, i) => i < prevItems.length && keyChanged(prevItems[i], item));
+      if (changed) {
+        for (const listener of listeners) {
+          listener(next);
+        }
+      }
+    }
+    prevItems = next;
+  });
+  const originalDestroy = base.destroy.bind(base);
+  return {
+    get() {
+      return base.get();
+    },
+    peek() {
+      return base.peek();
+    },
+    set(valueOrUpdater) {
+      base.set(valueOrUpdater);
+    },
+    subscribe(listener) {
+      return base.subscribe(listener);
+    },
+    reset() {
+      base.reset();
+    },
+    watch(watchKey, listener) {
+      let listeners = watchers.get(watchKey);
+      if (!listeners) {
+        listeners = /* @__PURE__ */ new Set();
+        watchers.set(watchKey, listeners);
+      }
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0) {
+          watchers.delete(watchKey);
+        }
+      };
+    },
+    add(...items) {
+      base.set((prev) => [...prev, ...items]);
+    },
+    remove(predicate, options2) {
+      if (options2?.one) {
+        let removed = false;
+        base.set(
+          (prev) => prev.filter((item) => {
+            if (!removed && predicate(item)) {
+              removed = true;
+              return false;
+            }
+            return true;
+          })
+        );
+      } else {
+        base.set((prev) => prev.filter((item) => !predicate(item)));
+      }
+    },
+    update(predicate, patch, options2) {
+      const applyPatch = typeof patch === "function" ? patch : (item) => ({ ...item, ...patch });
+      if (options2?.one) {
+        let updated = false;
+        base.set(
+          (prev) => prev.map((item) => {
+            if (!updated && predicate(item)) {
+              updated = true;
+              return applyPatch(item);
+            }
+            return item;
+          })
+        );
+      } else {
+        base.set((prev) => prev.map((item) => predicate(item) ? applyPatch(item) : item));
+      }
+    },
+    find(predicate) {
+      return base.get().find(predicate);
+    },
+    findAll(predicate) {
+      return base.get().filter(predicate);
+    },
+    has(predicate) {
+      return base.get().some(predicate);
+    },
+    get size() {
+      return base.get().length;
+    },
+    clear() {
+      base.set([]);
+    },
+    intercept(fn) {
+      return base.intercept(fn);
+    },
+    use(fn) {
+      return base.use(fn);
+    },
+    get scope() {
+      return base.scope;
+    },
+    get key() {
+      return base.key;
+    },
+    get isDestroyed() {
+      return base.isDestroyed;
+    },
+    get ready() {
+      return base.ready;
+    },
+    get settled() {
+      return base.settled;
+    },
+    get hydrated() {
+      return base.hydrated;
+    },
+    get destroyed() {
+      return base.destroyed;
+    },
+    destroy() {
+      watchers.clear();
+      unsubscribe();
+      originalDestroy();
+    }
+  };
+}
+
+// src/computed.ts
+function computed(deps, fn) {
+  const listeners = /* @__PURE__ */ new Set();
+  let cached;
+  let isDirty = true;
+  let isDestroyed = false;
+  function getDepValues() {
+    return deps.map((dep) => dep.get());
+  }
+  function recompute() {
+    if (!isDirty) return cached;
+    cached = fn(getDepValues());
+    isDirty = false;
+    return cached;
+  }
+  const notifyListeners = () => {
+    const value = recompute();
+    for (const listener of listeners) {
+      listener(value);
+    }
+  };
+  const unsubscribers = deps.map(
+    (dep) => dep.subscribe(() => {
+      isDirty = true;
+      notify(notifyListeners);
+    })
+  );
+  recompute();
+  let resolveDestroyed;
+  const destroyedPromise = new Promise((resolve) => {
+    resolveDestroyed = resolve;
+  });
+  return {
+    key: "",
+    scope: "render",
+    get ready() {
+      return Promise.all(deps.map((d) => d.ready)).then(() => void 0);
+    },
+    get settled() {
+      return Promise.all(deps.map((d) => d.settled)).then(() => void 0);
+    },
+    get hydrated() {
+      return Promise.all(deps.map((d) => d.hydrated)).then(() => void 0);
+    },
+    get destroyed() {
+      return destroyedPromise;
+    },
+    get isDestroyed() {
+      return isDestroyed;
+    },
+    get() {
+      return recompute();
+    },
+    peek() {
+      return recompute();
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    destroy() {
+      if (isDestroyed) return;
+      isDestroyed = true;
+      for (const unsub of unsubscribers) {
+        unsub();
+      }
+      listeners.clear();
+      resolveDestroyed();
+    }
+  };
+}
+
+// src/effect.ts
+function effect(deps, fn) {
+  let cleanup;
+  let isStopped = false;
+  function getDepValues() {
+    return deps.map((dep) => dep.get());
+  }
+  function run() {
+    if (isStopped) return;
+    if (cleanup) {
+      cleanup();
+      cleanup = void 0;
+    }
+    cleanup = fn(getDepValues());
+  }
+  const unsubscribers = deps.map((dep) => dep.subscribe(() => run()));
+  run();
+  return {
+    stop() {
+      if (isStopped) return;
+      isStopped = true;
+      for (const unsub of unsubscribers) {
+        unsub();
+      }
+      if (cleanup) {
+        cleanup();
+        cleanup = void 0;
+      }
+    }
+  };
+}
+
+// src/enhancers/watch.ts
+function withWatch(instance) {
+  const watchers = /* @__PURE__ */ new Map();
+  let prev = instance.get();
+  const unsubscribe = instance.subscribe((next) => {
+    if (watchers.size === 0) {
+      prev = next;
+      return;
+    }
+    if (next === null || typeof next !== "object") {
+      prev = next;
+      return;
+    }
+    for (const [watchKey, listeners] of watchers) {
+      const prevVal = prev !== null && typeof prev === "object" ? prev[watchKey] : void 0;
+      const nextVal = next[watchKey];
+      if (!Object.is(prevVal, nextVal)) {
+        for (const listener of listeners) {
+          listener(nextVal);
+        }
+      }
+    }
+    prev = next;
+  });
+  const originalDestroy = instance.destroy.bind(instance);
+  const result = Object.create(instance);
+  result.watch = (watchKey, listener) => {
+    if (!watchers.has(watchKey)) {
+      watchers.set(watchKey, /* @__PURE__ */ new Set());
+    }
+    const listeners = watchers.get(watchKey);
+    if (!listeners) return () => {
+    };
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        watchers.delete(watchKey);
+      }
+    };
+  };
+  result.destroy = () => {
+    watchers.clear();
+    unsubscribe();
+    originalDestroy();
+  };
+  return result;
+}
+
+// src/factory.ts
+var instanceCache = /* @__PURE__ */ new Map();
+function state(key, options) {
+  const config = getConfig();
+  const scope = options.scope ?? config.defaultScope ?? "render";
+  const ck = scopedKey(key, scope);
+  const cached = instanceCache.get(ck);
+  if (cached && !cached.isDestroyed) {
+    if (config.warnOnDuplicate) {
+      log("warn", `Duplicate state("${key}") with scope "${scope}". Returning cached instance.`);
+    }
+    return cached;
+  }
+  const base = createBase(key, options);
+  const instance = withWatch(base);
+  instanceCache.set(ck, instance);
+  return instance;
+}
+
+exports.batch = batch;
+exports.collection = collection;
+exports.computed = computed;
+exports.configure = configure;
+exports.effect = effect;
+exports.state = state;
+exports.withServerSession = withServerSession;
+exports.withWatch = withWatch;
+//# sourceMappingURL=chunk-GGB5QBDR.cjs.map
+//# sourceMappingURL=chunk-GGB5QBDR.cjs.map