gjendje 0.4.2 → 0.4.4

package/dist/chunk-WLY6NN5P.js

@@ -0,0 +1,1046 @@
+// src/batch.ts
+var depth = 0;
+var queue = /* @__PURE__ */ new Set();
+var flushBuf = new Array(16);
+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 size = queue.size;
+    if (size > flushBuf.length) {
+      flushBuf = new Array(size);
+    }
+    let i = 0;
+    for (const notification of queue) {
+      flushBuf[i++] = notification;
+    }
+    queue.clear();
+    depth++;
+    try {
+      for (let j = 0; j < size; j++) {
+        ;
+        flushBuf[j]();
+      }
+    } finally {
+      depth--;
+      for (let j = 0; j < size; j++) {
+        flushBuf[j] = void 0;
+      }
+    }
+  }
+}
+
+// src/config.ts
+var globalConfig = {};
+function configure(config) {
+  globalConfig = { ...globalConfig, ...config };
+}
+function getConfig() {
+  return globalConfig;
+}
+var LOG_PRIORITY = { debug: 0, warn: 1, error: 2 };
+function log(level, message) {
+  const configLevel = globalConfig.logLevel ?? "warn";
+  if (configLevel === "silent") return;
+  if (LOG_PRIORITY[level] >= LOG_PRIORITY[configLevel]) {
+    console[level](`[gjendje] ${message}`);
+  }
+}
+function reportError(key, scope, error) {
+  globalConfig.onError?.({ key, scope, error });
+}
+
+// src/utils.ts
+function shallowEqual(a, b) {
+  if (Object.is(a, b)) return true;
+  if (typeof a !== typeof b) return false;
+  if (a === null || b === null) return false;
+  if (typeof a !== "object" || typeof b !== "object") return false;
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b)) return false;
+    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;
+  }
+  if (Array.isArray(b)) return false;
+  const objA = a;
+  const objB = b;
+  const keysA = Object.keys(objA);
+  const keysB = Object.keys(objB);
+  if (keysA.length !== keysB.length) return false;
+  for (let i = 0; i < keysA.length; i++) {
+    const key = keysA[i];
+    if (!Object.hasOwn(objB, key) || !Object.is(objA[key], objB[key])) return false;
+  }
+  return true;
+}
+
+// src/listeners.ts
+function createListeners() {
+  const set = /* @__PURE__ */ new Set();
+  return {
+    notify(value) {
+      for (const listener of set) {
+        try {
+          listener(value);
+        } catch (err) {
+          console.error("[gjendje] Listener threw:", err);
+        }
+      }
+    },
+    subscribe(listener) {
+      set.add(listener);
+      return () => {
+        set.delete(listener);
+      };
+    },
+    clear() {
+      set.clear();
+    }
+  };
+}
+
+// src/registry.ts
+function scopedKey(key, scope) {
+  return `${scope}:${key}`;
+}
+var registry = /* @__PURE__ */ new Map();
+function getRegistered(rKey) {
+  return registry.get(rKey);
+}
+function registerByKey(rKey, key, scope, instance, config) {
+  const existing = registry.get(rKey);
+  if (existing !== void 0) {
+    if (existing.isDestroyed) {
+      registry.set(rKey, instance);
+    } else if (config.warnOnDuplicate) {
+      log("warn", `Duplicate state("${key}") with scope "${scope}". Returning cached instance.`);
+    }
+    return;
+  }
+  if (config.maxKeys !== void 0 && registry.size >= config.maxKeys) {
+    throw new Error(
+      `[gjendje] maxKeys limit (${config.maxKeys}) reached. Cannot register state("${key}") with scope "${scope}".`
+    );
+  }
+  registry.set(rKey, instance);
+  config.onRegister?.({ key, scope });
+}
+function unregisterByKey(rKey) {
+  registry.delete(rKey);
+}
+function getRegistry() {
+  return registry;
+}
+
+// src/persist.ts
+function isVersionedValue(value) {
+  const hasShape = value !== null && typeof value === "object" && "v" in value && "data" in value;
+  return hasShape && Number.isSafeInteger(value.v);
+}
+function readAndMigrate(raw, options, key, scope) {
+  const currentVersion = options.version ?? 1;
+  const defaultValue = options.default;
+  try {
+    const parsed = JSON.parse(raw);
+    let storedVersion = 1;
+    let data;
+    if (isVersionedValue(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 (Object.hasOwn(value, k)) {
+      partial[k] = value[k];
+    }
+  }
+  return partial;
+}
+function mergeKeys(stored, defaultValue, keys) {
+  if (!keys || typeof stored !== "object" || stored === null) return stored;
+  return { ...defaultValue, ...stored };
+}
+var MAX_MIGRATION_STEPS = 1e3;
+function runMigrations(data, fromVersion, toVersion, migrations) {
+  if (fromVersion < 0 || toVersion - fromVersion > MAX_MIGRATION_STEPS) {
+    log("warn", `Migration range v${fromVersion}\u2192v${toVersion} is out of bounds \u2014 skipping.`);
+    return data;
+  }
+  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 = createListeners();
+  let cachedRaw;
+  let cachedValue;
+  function parse(raw) {
+    if (serialize) {
+      return serialize.parse(raw);
+    }
+    return readAndMigrate(raw, options, key, options.scope);
+  }
+  function read() {
+    try {
+      const raw = storage.getItem(key);
+      if (raw === null) {
+        cachedRaw = null;
+        cachedValue = void 0;
+        return defaultValue;
+      }
+      if (raw === cachedRaw) return cachedValue;
+      let value;
+      try {
+        value = parse(raw);
+      } catch {
+        cachedRaw = void 0;
+        cachedValue = void 0;
+        return defaultValue;
+      }
+      value = mergeKeys(value, defaultValue, persist);
+      cachedRaw = raw;
+      cachedValue = value;
+      return value;
+    } 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);
+      cachedRaw = void 0;
+      cachedValue = void 0;
+    } catch (e) {
+      cachedRaw = void 0;
+      cachedValue = void 0;
+      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 = () => listeners.notify(lastNotifiedValue);
+  function onStorageEvent(event) {
+    if (event.storageArea !== storage || event.key !== key) return;
+    cachedRaw = void 0;
+    cachedValue = void 0;
+    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: listeners.subscribe,
+    destroy() {
+      cachedRaw = void 0;
+      cachedValue = void 0;
+      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 = createListeners();
+  let lastNotifiedValue = defaultValue;
+  const notifyListeners = () => listeners.notify(lastNotifiedValue);
+  const fallbackStorage = fallbackScope === "tab" ? sessionStorage : localStorage;
+  let delegate = createStorageAdapter(fallbackStorage, key, options);
+  let isDestroyed = false;
+  const ready = (async () => {
+    if (!isBucketSupported()) return;
+    try {
+      const openOptions = {
+        persisted: bucketOptions.persisted ?? false,
+        durability: "strict"
+      };
+      if (bucketOptions.expires != null) {
+        const parsed = parseExpiry(bucketOptions.expires);
+        if (parsed != null) {
+          openOptions.expires = parsed;
+        } else {
+          log(
+            "warn",
+            `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 {
+          log(
+            "warn",
+            `Invalid bucket quota format: "${bucketOptions.quota}". Expected a number or a string like "10mb", "50kb", "1gb".`
+          );
+        }
+      }
+      const bucketManager = navigator.storageBuckets;
+      if (!bucketManager) return;
+      const bucket = await bucketManager.open(bucketOptions.name, openOptions);
+      const storage = await bucket.localStorage();
+      if (isDestroyed) return;
+      const currentValue = delegate.get();
+      const hadUserWrite = !shallowEqual(currentValue, defaultValue);
+      delegate.destroy?.();
+      delegate = createStorageAdapter(storage, key, options);
+      if (hadUserWrite) {
+        delegate.set(currentValue);
+      }
+    } catch {
+    }
+    if (isDestroyed) return;
+    const storedValue = delegate.get();
+    if (!shallowEqual(storedValue, defaultValue)) {
+      lastNotifiedValue = storedValue;
+      notify(notifyListeners);
+    }
+    delegate.subscribe((value) => {
+      lastNotifiedValue = value;
+      notify(notifyListeners);
+    });
+  })();
+  return {
+    ready,
+    get() {
+      return delegate.get();
+    },
+    set(value) {
+      delegate.set(value);
+      lastNotifiedValue = value;
+      notify(notifyListeners);
+    },
+    subscribe: listeners.subscribe,
+    destroy() {
+      isDestroyed = true;
+      listeners.clear();
+      delegate.destroy?.();
+    }
+  };
+}
+
+// src/adapters/render.ts
+var RESOLVED = Promise.resolve();
+function createRenderAdapter(defaultValue) {
+  let current = defaultValue;
+  const listeners = /* @__PURE__ */ new Set();
+  const notifyListeners = () => {
+    for (const listener of listeners) {
+      try {
+        listener(current);
+      } catch (err) {
+        console.error("[gjendje] Listener threw:", err);
+      }
+    }
+  };
+  return {
+    ready: RESOLVED,
+    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 = createListeners();
+  adapter.subscribe((value) => {
+    listeners.notify(value);
+  });
+  if (channel) {
+    channel.onmessage = (event) => {
+      const msg = event.data;
+      if (msg == null || typeof msg !== "object" || !("value" in msg)) return;
+      if (Object.keys(msg).length !== 1) return;
+      const value = msg.value;
+      try {
+        adapter.set(value);
+        if (scope) {
+          getConfig().onSync?.({ key, scope, value, source: "remote" });
+        }
+      } catch (err) {
+        log(
+          "error",
+          `Sync failed for key "${key}": ${err instanceof Error ? err.message : String(err)}`
+        );
+        if (scope) {
+          reportError(key, scope, err);
+        }
+      }
+    };
+  }
+  return {
+    get ready() {
+      return adapter.ready;
+    },
+    get() {
+      return adapter.get();
+    },
+    set(value) {
+      adapter.set(value);
+      channel?.postMessage({ value });
+    },
+    subscribe(listener) {
+      return listeners.subscribe(listener);
+    },
+    destroy() {
+      listeners.clear();
+      channel?.close();
+      adapter.destroy?.();
+    }
+  };
+}
+
+// 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 = createListeners();
+  const defaultSerialized = serializer.stringify(defaultValue);
+  function read() {
+    try {
+      const params = new URLSearchParams(window.location.search);
+      const raw = params.get(key);
+      if (raw === null) return defaultValue;
+      return mergeKeys(serializer.parse(raw), defaultValue, persist);
+    } catch {
+      return defaultValue;
+    }
+  }
+  function write(value) {
+    try {
+      const params = new URLSearchParams(window.location.search);
+      const toStore = pickKeys(value, persist);
+      const stringified = serializer.stringify(toStore);
+      const isDefault = stringified === defaultSerialized;
+      if (isDefault) {
+        params.delete(key);
+      } else {
+        params.set(key, 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);
+    } catch {
+    }
+  }
+  let lastNotifiedValue = defaultValue;
+  const notifyListeners = () => listeners.notify(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: listeners.subscribe,
+    destroy() {
+      listeners.clear();
+      window.removeEventListener("popstate", onPopState);
+    }
+  };
+}
+
+// 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 _serverAdapterFactory;
+function registerServerAdapter(factory) {
+  _serverAdapterFactory = factory;
+}
+var PERSISTENT_SCOPES = /* @__PURE__ */ new Set(["local", "tab", "bucket"]);
+var SYNCABLE_SCOPES = /* @__PURE__ */ new Set(["local", "bucket"]);
+var RESOLVED2 = Promise.resolve();
+var RENDER_SHIM = {
+  ready: RESOLVED2,
+  get: () => void 0,
+  set: () => {
+  },
+  subscribe: () => () => {
+  }
+};
+function resolveStorageKey(key, options, configPrefix) {
+  if (options.prefix === false) return key;
+  const prefix = options.prefix ?? configPrefix;
+  return prefix ? `${prefix}:${key}` : key;
+}
+function resolveAdapter(storageKey, scope, options) {
+  switch (scope) {
+    case "render":
+      return createRenderAdapter(options.default);
+    case "tab":
+      if (typeof sessionStorage === "undefined") {
+        throw new Error(
+          '[state] sessionStorage is not available. Use ssr: true or scope: "render" for server environments.'
+        );
+      }
+      return createStorageAdapter(sessionStorage, storageKey, options);
+    case "local":
+      if (typeof localStorage === "undefined") {
+        throw new Error(
+          '[state] localStorage is not available. Use ssr: true or scope: "server" for server environments.'
+        );
+      }
+      return createStorageAdapter(localStorage, 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":
+      if (!_serverAdapterFactory) {
+        throw new Error(
+          '[state] scope: "server" requires the server adapter. Import { withServerSession } from "gjendje" or "gjendje/server" to enable it.'
+        );
+      }
+      return _serverAdapterFactory(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}`);
+    }
+  }
+}
+var StateImpl = class {
+  key;
+  scope;
+  _adapter;
+  _defaultValue;
+  _options;
+  _rKey;
+  _config;
+  _s;
+  constructor(key, scope, rKey, adapter, options, config) {
+    this.key = key;
+    this.scope = scope;
+    this._rKey = rKey;
+    this._adapter = adapter;
+    this._defaultValue = options.default;
+    this._options = options;
+    this._config = config;
+    this._s = {
+      lastValue: adapter.get(),
+      isDestroyed: false,
+      interceptors: void 0,
+      hooks: void 0,
+      settled: RESOLVED2,
+      resolveDestroyed: void 0,
+      destroyed: void 0,
+      hydrated: void 0,
+      watchers: void 0,
+      watchUnsub: void 0,
+      watchPrev: void 0
+    };
+  }
+  get() {
+    return this._s.isDestroyed ? this._s.lastValue : this._adapter.get();
+  }
+  peek() {
+    return this._s.isDestroyed ? this._s.lastValue : this._adapter.get();
+  }
+  set(valueOrUpdater) {
+    const s = this._s;
+    if (s.isDestroyed) return;
+    const prev = this._adapter.get();
+    let next = typeof valueOrUpdater === "function" ? valueOrUpdater(prev) : valueOrUpdater;
+    if (s.interceptors !== void 0 && s.interceptors.size > 0) {
+      for (const interceptor of s.interceptors) {
+        next = interceptor(next, prev);
+      }
+    }
+    if (this._options.isEqual?.(next, prev)) return;
+    s.lastValue = next;
+    this._adapter.set(next);
+    s.settled = this._adapter.ready;
+    if (s.hooks !== void 0 && s.hooks.size > 0) {
+      for (const hook of s.hooks) {
+        hook(next, prev);
+      }
+    }
+  }
+  subscribe(listener) {
+    return this._adapter.subscribe(listener);
+  }
+  reset() {
+    const s = this._s;
+    if (s.isDestroyed) return;
+    const prev = this._adapter.get();
+    let next = this._defaultValue;
+    if (s.interceptors !== void 0 && s.interceptors.size > 0) {
+      for (const interceptor of s.interceptors) {
+        next = interceptor(next, prev);
+      }
+    }
+    if (this._options.isEqual?.(next, prev)) return;
+    s.lastValue = next;
+    this._adapter.set(next);
+    s.settled = this._adapter.ready;
+    if (s.hooks !== void 0 && s.hooks.size > 0) {
+      for (const hook of s.hooks) {
+        hook(next, prev);
+      }
+    }
+  }
+  get ready() {
+    return this._adapter.ready;
+  }
+  get settled() {
+    return this._s.settled;
+  }
+  get hydrated() {
+    return this._s.hydrated ?? RESOLVED2;
+  }
+  get destroyed() {
+    const s = this._s;
+    if (!s.destroyed) {
+      s.destroyed = new Promise((resolve) => {
+        s.resolveDestroyed = resolve;
+      });
+    }
+    return s.destroyed;
+  }
+  get isDestroyed() {
+    return this._s.isDestroyed;
+  }
+  intercept(fn) {
+    const s = this._s;
+    if (!s.interceptors) s.interceptors = /* @__PURE__ */ new Set();
+    s.interceptors.add(fn);
+    return () => {
+      s.interceptors?.delete(fn);
+    };
+  }
+  use(fn) {
+    const s = this._s;
+    if (!s.hooks) s.hooks = /* @__PURE__ */ new Set();
+    s.hooks.add(fn);
+    return () => {
+      s.hooks?.delete(fn);
+    };
+  }
+  watch(watchKey, listener) {
+    const s = this._s;
+    if (!s.watchers) s.watchers = /* @__PURE__ */ new Map();
+    this._ensureWatchSubscription();
+    let listeners = s.watchers.get(watchKey);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      s.watchers.set(watchKey, listeners);
+    }
+    listeners.add(listener);
+    const watcherMap = s.watchers;
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        watcherMap.delete(watchKey);
+      }
+    };
+  }
+  destroy() {
+    const s = this._s;
+    if (s.isDestroyed) return;
+    s.lastValue = this._adapter.get();
+    s.isDestroyed = true;
+    s.interceptors?.clear();
+    s.hooks?.clear();
+    s.watchers?.clear();
+    s.watchUnsub?.();
+    this._adapter.destroy?.();
+    unregisterByKey(this._rKey);
+    this._config.onDestroy?.({ key: this.key, scope: this.scope });
+    if (s.resolveDestroyed) {
+      s.resolveDestroyed();
+    } else {
+      s.destroyed = RESOLVED2;
+    }
+  }
+  _ensureWatchSubscription() {
+    const s = this._s;
+    if (s.watchUnsub) return;
+    s.watchPrev = this._adapter.get();
+    s.watchUnsub = this._adapter.subscribe((next) => {
+      if (!s.watchers || s.watchers.size === 0) {
+        s.watchPrev = next;
+        return;
+      }
+      for (const [watchKey, listeners] of s.watchers) {
+        const prevVal = s.watchPrev !== null && typeof s.watchPrev === "object" ? s.watchPrev[watchKey] : void 0;
+        const nextVal = next !== null && typeof next === "object" ? next[watchKey] : void 0;
+        if (!Object.is(prevVal, nextVal)) {
+          for (const listener of listeners) {
+            listener(nextVal);
+          }
+        }
+      }
+      s.watchPrev = next;
+    });
+  }
+};
+var RenderStateImpl = class extends StateImpl {
+  // Direct reference — avoids a getter cast on every get()/set() call
+  _r;
+  _hasIsEqual;
+  constructor(key, rKey, options, config) {
+    super(key, "render", rKey, RENDER_SHIM, options, config);
+    const rs = this._s;
+    rs.current = options.default;
+    rs.renderListeners = void 0;
+    rs.notifyFn = void 0;
+    this._r = rs;
+    this._hasIsEqual = options.isEqual !== void 0;
+  }
+  get() {
+    return this._r.current;
+  }
+  peek() {
+    return this._r.current;
+  }
+  set(valueOrUpdater) {
+    const s = this._r;
+    if (s.isDestroyed) return;
+    const prev = s.current;
+    let next = typeof valueOrUpdater === "function" ? valueOrUpdater(prev) : valueOrUpdater;
+    if (s.interceptors !== void 0 && s.interceptors.size > 0) {
+      for (const interceptor of s.interceptors) {
+        next = interceptor(next, prev);
+      }
+    }
+    if (this._hasIsEqual && this._options.isEqual?.(next, prev)) return;
+    s.current = next;
+    if (s.notifyFn !== void 0) {
+      notify(s.notifyFn);
+    }
+    if (s.hooks !== void 0 && s.hooks.size > 0) {
+      for (const hook of s.hooks) {
+        hook(next, prev);
+      }
+    }
+  }
+  subscribe(listener) {
+    const s = this._r;
+    if (!s.renderListeners) {
+      const listeners = /* @__PURE__ */ new Set();
+      s.renderListeners = listeners;
+      s.notifyFn = () => {
+        for (const l of listeners) {
+          try {
+            l(s.current);
+          } catch (err) {
+            console.error("[gjendje] Listener threw:", err);
+          }
+        }
+      };
+    }
+    const set = s.renderListeners;
+    set.add(listener);
+    return () => {
+      set.delete(listener);
+    };
+  }
+  reset() {
+    const s = this._r;
+    if (s.isDestroyed) return;
+    const prev = s.current;
+    let next = this._defaultValue;
+    if (s.interceptors !== void 0 && s.interceptors.size > 0) {
+      for (const interceptor of s.interceptors) {
+        next = interceptor(next, prev);
+      }
+    }
+    if (this._hasIsEqual && this._options.isEqual?.(next, prev)) return;
+    s.current = next;
+    if (s.notifyFn !== void 0) {
+      notify(s.notifyFn);
+    }
+    if (s.hooks !== void 0 && s.hooks.size > 0) {
+      for (const hook of s.hooks) {
+        hook(next, prev);
+      }
+    }
+  }
+  get ready() {
+    return RESOLVED2;
+  }
+  _ensureWatchSubscription() {
+    const s = this._r;
+    if (s.watchUnsub) return;
+    s.watchPrev = s.current;
+    s.watchUnsub = this.subscribe((next) => {
+      if (!s.watchers || s.watchers.size === 0) {
+        s.watchPrev = next;
+        return;
+      }
+      for (const [watchKey, listeners] of s.watchers) {
+        const prevVal = s.watchPrev !== null && typeof s.watchPrev === "object" ? s.watchPrev[watchKey] : void 0;
+        const nextVal = next !== null && typeof next === "object" ? next[watchKey] : void 0;
+        if (!Object.is(prevVal, nextVal)) {
+          for (const listener of listeners) {
+            listener(nextVal);
+          }
+        }
+      }
+      s.watchPrev = next;
+    });
+  }
+  destroy() {
+    const s = this._r;
+    if (s.isDestroyed) return;
+    s.lastValue = s.current;
+    s.isDestroyed = true;
+    s.interceptors?.clear();
+    s.hooks?.clear();
+    s.watchers?.clear();
+    s.watchUnsub?.();
+    s.renderListeners?.clear();
+    unregisterByKey(this._rKey);
+    this._config.onDestroy?.({ key: this.key, scope: this.scope });
+    if (s.resolveDestroyed) {
+      s.resolveDestroyed();
+    } else {
+      s.destroyed = RESOLVED2;
+    }
+  }
+};
+function createRenderState(key, rKey, options, config) {
+  return new RenderStateImpl(key, rKey, options, config);
+}
+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(
+      `[gjendje] Key "${key}" does not match the configured keyPattern ${config.keyPattern}.`
+    );
+  }
+  const scope = options.scope ?? config.scope ?? "render";
+  const rKey = scopedKey(key, scope);
+  const existing = getRegistered(rKey);
+  if (existing && !existing.isDestroyed) return existing;
+  if (config.requireValidation && PERSISTENT_SCOPES.has(scope) && !options.validate) {
+    throw new Error(
+      `[gjendje] A validate function is required for persisted scope "${scope}" on state("${key}"). Set requireValidation: false in configure() to disable.`
+    );
+  }
+  const isSsrMode = (options.ssr ?? config.ssr) && BROWSER_SCOPES.has(scope);
+  const useRenderFallback = isSsrMode && isServer();
+  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.`
+    );
+  }
+  let instance;
+  if (scope === "render" && !isSsrMode) {
+    instance = new RenderStateImpl(key, rKey, options, config);
+  } else {
+    const storageKey = resolveStorageKey(key, options, config.prefix);
+    const baseAdapter = useRenderFallback ? createRenderAdapter(options.default) : resolveAdapter(storageKey, scope, options);
+    const shouldSync = effectiveSync && SYNCABLE_SCOPES.has(scope) && !useRenderFallback;
+    const adapter = shouldSync ? withSync(baseAdapter, storageKey, scope) : baseAdapter;
+    instance = new StateImpl(key, scope, rKey, adapter, options, config);
+    if (isSsrMode && !isServer()) {
+      instance._s.hydrated = afterHydration(() => {
+        try {
+          const realAdapter = resolveAdapter(storageKey, scope, options);
+          const storedValue = realAdapter.get();
+          const serverValue = options.default;
+          const clientValue = storedValue;
+          if (!shallowEqual(storedValue, options.default)) {
+            instance.set(storedValue);
+          }
+          config.onHydrate?.({ key, scope, serverValue, clientValue });
+          realAdapter.destroy?.();
+        } catch (err) {
+          log("debug", `Hydration adapter unavailable for state("${key}") \u2014 using render fallback.`);
+          reportError(key, scope, err);
+        }
+      });
+    }
+  }
+  registerByKey(rKey, key, scope, instance, config);
+  return instance;
+}
+
+export { batch, configure, createBase, createListeners, createRenderState, getConfig, getRegistered, getRegistry, log, notify, registerByKey, registerServerAdapter, scopedKey, shallowEqual };