gjendje 0.1.0

package/dist/factory-CIj-6WlO.d.ts

@@ -0,0 +1,316 @@
+type Scope = 'render' | 'tab' | 'local' | 'url' | 'server' | 'bucket';
+interface Adapter<T> {
+    get(): T;
+    set(value: T): void;
+    subscribe(listener: Listener<T>): Unsubscribe;
+    /** Resolves when the adapter is ready to read/write. Sync adapters resolve immediately. */
+    ready: Promise<void>;
+    destroy?(): void;
+}
+interface ReadonlyInstance<T> {
+    /** Current value */
+    get(): T;
+    /** Read the current value without any reactive implications */
+    peek(): T;
+    /** Subscribe to all changes. Returns an unsubscribe function. */
+    subscribe(listener: Listener<T>): Unsubscribe;
+    /** Which scope this instance uses */
+    readonly scope: Scope;
+    /** The key this instance was created with */
+    readonly key: string;
+    /** Whether this instance has been destroyed */
+    readonly isDestroyed: boolean;
+    /**
+     * Resolves when the adapter is fully initialized.
+     * Resolves immediately for synchronous scopes.
+     */
+    readonly ready: Promise<void>;
+    /**
+     * Resolves when the most recent write has been persisted to storage.
+     * For synchronous scopes this resolves immediately.
+     * For async scopes (e.g. bucket) this resolves once the adapter is ready
+     * and the write has landed.
+     */
+    readonly settled: Promise<void>;
+    /**
+     * Resolves when SSR hydration is complete and the real stored value
+     * has been read. Resolves immediately when not in SSR mode.
+     */
+    readonly hydrated: Promise<void>;
+    /**
+     * Resolves when destroy() has been called and teardown is complete.
+     */
+    readonly destroyed: Promise<void>;
+    /** Tear down listeners and storage resources */
+    destroy(): void;
+}
+interface BaseInstance<T> extends ReadonlyInstance<T> {
+    /** Update value — accepts a value or an updater function */
+    set(value: T | ((prev: T) => T)): void;
+    /** Reset to default value */
+    reset(): void;
+    /**
+     * Register an interceptor that runs before each set/reset.
+     * The interceptor receives `(next, prev)` and returns the value to actually store.
+     * Return `prev` to reject the update. Multiple interceptors run in registration order.
+     */
+    intercept(fn: (next: T, prev: T) => T): Unsubscribe;
+    /**
+     * Register a post-set tap that fires after each set/reset.
+     * Receives `(next, prev)`. Return value is ignored.
+     * Multiple hooks run in registration order.
+     */
+    use(fn: (next: T, prev: T) => void): Unsubscribe;
+}
+type Enhancer<TIn, TOut extends TIn> = (instance: TIn) => TOut;
+interface StateInstance<T> extends BaseInstance<T> {
+    /**
+     * Watch a specific key within an object value.
+     * Listener only fires when that key's value changes.
+     */
+    watch<K extends T extends object ? keyof T : never>(key: K, listener: (value: T[K & keyof T]) => void): Unsubscribe;
+}
+interface BucketOptions {
+    /**
+     * Name of the storage bucket. Each name is isolated — keys in one
+     * bucket never conflict with keys in another.
+     */
+    name: string;
+    /**
+     * Whether the bucket should persist under storage pressure.
+     * Defaults to false.
+     */
+    persisted?: boolean;
+    /**
+     * Expiry duration or Unix timestamp in ms.
+     * Examples: '7d', '24h', '30m', or a timestamp.
+     */
+    expires?: string | number;
+    /**
+     * Maximum storage quota for this bucket.
+     * Examples: '10mb', '50mb', or a byte count.
+     */
+    quota?: string | number;
+    /**
+     * Scope to use if the Storage Buckets API is not available.
+     * Defaults to 'local'.
+     */
+    fallback?: 'local' | 'tab';
+}
+interface StateOptions<T> {
+    /** Initial / default value */
+    default: T;
+    /** Where state should live. Defaults to 'render'. */
+    scope?: Scope;
+    /**
+     * Storage bucket options. Required when scope is 'bucket'.
+     * Ignored for all other scopes.
+     */
+    bucket?: BucketOptions;
+    /**
+     * Custom serializer. Defaults to JSON.stringify / JSON.parse.
+     * Only used by adapters that persist to string-based storage.
+     */
+    serialize?: Serializer<T>;
+    /**
+     * Enable SSR safety. When true:
+     * - On server: silently falls back to 'render' scope
+     * - On client before hydration: uses default value to match server output
+     * - On client after hydration: reads real storage and emits update if different
+     */
+    ssr?: boolean;
+    /**
+     * Schema version for migrations. Defaults to 1.
+     */
+    version?: number;
+    /**
+     * Validate a value read from storage. Falls back to default on failure.
+     * Runs after migration.
+     */
+    validate?: (value: unknown) => value is T;
+    /**
+     * Migration functions keyed by the version they migrate FROM.
+     *
+     * Example: { 1: (old) => ({ ...old, newField: 'default' }) }
+     */
+    migrate?: Record<number, (old: unknown) => unknown>;
+    /**
+     * Override the global prefix for this instance.
+     * - `string`: use this prefix instead of the global one
+     * - `false`: disable prefixing entirely for this instance
+     */
+    prefix?: string | false;
+    /**
+     * Broadcast changes to other tabs via BroadcastChannel.
+     * When true, any set() call is also sent to other open tabs,
+     * and incoming changes from other tabs update this instance.
+     *
+     * Works with any persistent scope (local, tab, bucket).
+     */
+    sync?: boolean;
+    /**
+     * Selectively persist only the specified keys of an object value.
+     * Non-listed keys are kept in memory but excluded from storage writes.
+     * On read, persisted keys are merged with the default value.
+     *
+     * Only meaningful for object-typed state with a persistent scope.
+     */
+    persist?: Array<keyof T & string>;
+}
+interface Serializer<T> {
+    stringify(value: T): string;
+    parse(raw: string): T;
+}
+type Listener<T> = (value: T) => void;
+type Unsubscribe = () => void;
+
+declare function withServerSession<T>(fn: () => T): Promise<T>;
+
+/**
+ * Runs all state updates inside fn as a single batch.
+ * Subscribers are notified once after all updates complete,
+ * rather than once per individual update.
+ *
+ * Nested batch() calls are safe — notifications flush only
+ * when the outermost batch completes.
+ *
+ * ```ts
+ * batch(() => {
+ *   firstName.set('John')
+ *   lastName.set('Doe')
+ *   age.set(30)
+ * })
+ * // subscribers fire once, not three times
+ * ```
+ */
+declare function batch(fn: () => void): void;
+
+interface CollectionInstance<T> extends BaseInstance<T[]> {
+    /** Read the current value without any reactive implications */
+    peek(): T[];
+    /**
+     * Watch a specific key across all items.
+     * Fires whenever any item's value for that key changes.
+     * Receives the full updated array.
+     */
+    watch<K extends T extends object ? keyof T : never>(key: K, listener: (items: T[]) => void): Unsubscribe;
+    /** Add one or more items to the end of the collection */
+    add(...items: T[]): void;
+    /**
+     * Remove all items matching the predicate.
+     * Pass `{ one: true }` to remove only the first match.
+     */
+    remove(predicate: (item: T) => boolean, options?: {
+        one?: boolean;
+    }): void;
+    /**
+     * Update all items matching the predicate with a partial patch or updater.
+     * Pass `{ one: true }` to update only the first match.
+     */
+    update(predicate: (item: T) => boolean, patch: Partial<T> | ((item: T) => T), options?: {
+        one?: boolean;
+    }): void;
+    /** Find the first item matching the predicate */
+    find(predicate: (item: T) => boolean): T | undefined;
+    /** Find all items matching the predicate */
+    findAll(predicate: (item: T) => boolean): T[];
+    /** True if any item matches the predicate */
+    has(predicate: (item: T) => boolean): boolean;
+    /** Number of items in the collection */
+    readonly size: number;
+    /** Remove all items */
+    clear(): void;
+}
+/**
+ * Reactive array state with first-class mutation methods.
+ * Supports all the same scopes, SSR, validation, and migration as state().
+ *
+ * ```ts
+ * const todos = collection('todos', {
+ *   default: [] as Todo[],
+ *   scope: 'local',
+ * })
+ *
+ * todos.add({ id: '1', text: 'Buy milk', done: false })
+ * todos.update((t) => t.id === '1', { done: true })
+ * todos.remove((t) => t.done)
+ * todos.get()  // Todo[]
+ * ```
+ */
+declare function collection<T>(key: string, options: StateOptions<T[]>): CollectionInstance<T>;
+
+type DepValues$1<T extends ReadonlyArray<BaseInstance<unknown>>> = {
+    [K in keyof T]: T[K] extends BaseInstance<infer V> ? V : never;
+};
+/**
+ * A read-only reactive value derived from one or more dependencies.
+ * Extends ReadonlyInstance — has get, peek, subscribe, ready, and identity,
+ * but no set or reset since the value is always determined by its sources.
+ */
+interface ComputedInstance<T> extends ReadonlyInstance<T> {
+}
+/**
+ * Derive a reactive value from one or more state dependencies.
+ * Recomputes only when a dependency changes. Cached between changes.
+ * Participates in batch() — notifications are deferred like any other state.
+ *
+ * ```ts
+ * const firstName = state('firstName', { default: 'Jane' })
+ * const lastName = state('lastName', { default: 'Doe' })
+ *
+ * const fullName = computed([firstName, lastName], ([first, last]) => {
+ *   return `${first} ${last}`.trim()
+ * })
+ *
+ * fullName.get()       // 'Jane Doe'
+ * fullName.subscribe(name => console.log(name))
+ * ```
+ */
+declare function computed<TDeps extends ReadonlyArray<BaseInstance<unknown>>, TResult>(deps: TDeps, fn: (values: DepValues$1<TDeps>) => TResult): ComputedInstance<TResult>;
+
+type DepValues<T extends ReadonlyArray<BaseInstance<unknown>>> = {
+    [K in keyof T]: T[K] extends BaseInstance<infer V> ? V : never;
+};
+type Cleanup = () => void;
+interface EffectHandle {
+    /** Stop the effect and run the last cleanup function if any */
+    stop(): void;
+}
+/**
+ * Run a side effect when state dependencies change.
+ * Runs immediately with current values, then re-runs on any change.
+ *
+ * The callback can return a cleanup function that runs before the next
+ * execution and when the effect is stopped.
+ *
+ * ```ts
+ * const stop = effect([theme, fontSize], ([t, f]) => {
+ *   document.body.setAttribute('data-theme', t)
+ *   document.documentElement.style.fontSize = `${f}px`
+ *
+ *   return () => {
+ *     document.body.removeAttribute('data-theme')
+ *   }
+ * })
+ *
+ * // Later — stop listening and clean up
+ * stop()
+ * ```
+ */
+declare function effect<TDeps extends ReadonlyArray<BaseInstance<unknown>>>(deps: TDeps, fn: (values: DepValues<TDeps>) => Cleanup | undefined): EffectHandle;
+
+/**
+ * Create a stateful value.
+ *
+ * Same key + same scope always returns the same instance.
+ * Change scope to move state anywhere.
+ *
+ * ```ts
+ * const theme = state('theme', { default: 'light', scope: 'local' })
+ * const filters = state('filters', { default: {}, scope: 'url' })
+ * const user = state('user', { default: null, scope: 'server' })
+ * ```
+ */
+declare function state<T>(key: string, options: StateOptions<T>): StateInstance<T>;
+
+export { type Adapter as A, type BaseInstance as B, type CollectionInstance as C, type EffectHandle as E, type Listener as L, type ReadonlyInstance as R, type Scope as S, type Unsubscribe as U, type BucketOptions as a, type ComputedInstance as b, type Enhancer as c, type Serializer as d, type StateInstance as e, type StateOptions as f, batch as g, collection as h, computed as i, effect as j, state as s, withServerSession as w };

package/dist/index.cjs

@@ -0,0 +1,40 @@
+'use strict';
+
+var chunkGGB5QBDR_cjs = require('./chunk-GGB5QBDR.cjs');
+
+
+
+Object.defineProperty(exports, "batch", {
+  enumerable: true,
+  get: function () { return chunkGGB5QBDR_cjs.batch; }
+});
+Object.defineProperty(exports, "collection", {
+  enumerable: true,
+  get: function () { return chunkGGB5QBDR_cjs.collection; }
+});
+Object.defineProperty(exports, "computed", {
+  enumerable: true,
+  get: function () { return chunkGGB5QBDR_cjs.computed; }
+});
+Object.defineProperty(exports, "configure", {
+  enumerable: true,
+  get: function () { return chunkGGB5QBDR_cjs.configure; }
+});
+Object.defineProperty(exports, "effect", {
+  enumerable: true,
+  get: function () { return chunkGGB5QBDR_cjs.effect; }
+});
+Object.defineProperty(exports, "state", {
+  enumerable: true,
+  get: function () { return chunkGGB5QBDR_cjs.state; }
+});
+Object.defineProperty(exports, "withServerSession", {
+  enumerable: true,
+  get: function () { return chunkGGB5QBDR_cjs.withServerSession; }
+});
+Object.defineProperty(exports, "withWatch", {
+  enumerable: true,
+  get: function () { return chunkGGB5QBDR_cjs.withWatch; }
+});
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/index.d.cts

@@ -0,0 +1,90 @@
+import { S as Scope, U as Unsubscribe, B as BaseInstance } from './factory-CIj-6WlO.cjs';
+export { A as Adapter, a as BucketOptions, C as CollectionInstance, b as ComputedInstance, E as EffectHandle, c as Enhancer, L as Listener, R as ReadonlyInstance, d as Serializer, e as StateInstance, f as StateOptions, g as batch, h as collection, i as computed, j as effect, s as state, w as withServerSession } from './factory-CIj-6WlO.cjs';
+
+type LogLevel = 'silent' | 'warn' | 'error' | 'debug';
+interface ErrorContext {
+    key: string;
+    scope: Scope;
+    error: unknown;
+}
+interface DestroyContext {
+    key: string;
+    scope: Scope;
+}
+interface MigrateContext {
+    key: string;
+    scope: Scope;
+    fromVersion: number;
+    toVersion: number;
+    data: unknown;
+}
+interface QuotaExceededContext {
+    key: string;
+    scope: Scope;
+    error: unknown;
+}
+interface HydrateContext {
+    key: string;
+    scope: Scope;
+    serverValue: unknown;
+    clientValue: unknown;
+}
+interface SyncContext {
+    key: string;
+    scope: Scope;
+    value: unknown;
+    source: 'remote';
+}
+interface RegisterContext {
+    key: string;
+    scope: Scope;
+}
+interface SteadConfig {
+    /** Default scope for all state instances. Defaults to `'render'`. */
+    defaultScope?: Scope | undefined;
+    /** Enforce a naming pattern for state keys. */
+    keyPattern?: RegExp | undefined;
+    /** Control log verbosity for internal warnings and errors. Defaults to `'warn'`. */
+    logLevel?: LogLevel | undefined;
+    /** Cap the total number of registered state instances. */
+    maxKeys?: number | undefined;
+    /** Prepends to all storage keys (e.g. `myapp:theme`) */
+    prefix?: string | undefined;
+    /** Require a validate option for persisted scopes (local, tab, bucket). */
+    requireValidation?: boolean | undefined;
+    /** Enable SSR mode globally for all instances. */
+    ssr?: boolean | undefined;
+    /** Enable cross-tab sync globally for all syncable scopes. */
+    sync?: boolean | undefined;
+    /** Warn when two state() calls use the same key + scope. */
+    warnOnDuplicate?: boolean | undefined;
+    /** Fires when any instance is destroyed. */
+    onDestroy?: ((context: DestroyContext) => void) | undefined;
+    /** Global error handler for storage/migration/validation failures. */
+    onError?: ((context: ErrorContext) => void) | undefined;
+    /** Fires after SSR hydration completes for an instance. */
+    onHydrate?: ((context: HydrateContext) => void) | undefined;
+    /** Fires after a migration chain runs during read. */
+    onMigrate?: ((context: MigrateContext) => void) | undefined;
+    /** Fires when a storage write fails due to quota. */
+    onQuotaExceeded?: ((context: QuotaExceededContext) => void) | undefined;
+    /** Fires when a new state instance is registered. */
+    onRegister?: ((context: RegisterContext) => void) | undefined;
+    /** Fires when a cross-tab sync event updates a value. */
+    onSync?: ((context: SyncContext) => void) | undefined;
+}
+declare function configure(config: SteadConfig): void;
+
+interface WithWatch<T> {
+    /**
+     * Watch a specific key within an object value.
+     * The listener only fires when that key's value changes,
+     * using Object.is for comparison.
+     *
+     * Returns an unsubscribe function.
+     */
+    watch<K extends T extends object ? keyof T : never>(key: K, listener: (value: T[K & keyof T]) => void): Unsubscribe;
+}
+declare function withWatch<TIn extends BaseInstance<any>>(instance: TIn): TIn & WithWatch<TIn extends BaseInstance<infer T> ? T : unknown>;
+
+export { BaseInstance, type DestroyContext, type ErrorContext, type HydrateContext, type LogLevel, type MigrateContext, type QuotaExceededContext, type RegisterContext, Scope, type SteadConfig, type SyncContext, Unsubscribe, type WithWatch, configure, withWatch };

package/dist/index.d.ts

@@ -0,0 +1,90 @@
+import { S as Scope, U as Unsubscribe, B as BaseInstance } from './factory-CIj-6WlO.js';
+export { A as Adapter, a as BucketOptions, C as CollectionInstance, b as ComputedInstance, E as EffectHandle, c as Enhancer, L as Listener, R as ReadonlyInstance, d as Serializer, e as StateInstance, f as StateOptions, g as batch, h as collection, i as computed, j as effect, s as state, w as withServerSession } from './factory-CIj-6WlO.js';
+
+type LogLevel = 'silent' | 'warn' | 'error' | 'debug';
+interface ErrorContext {
+    key: string;
+    scope: Scope;
+    error: unknown;
+}
+interface DestroyContext {
+    key: string;
+    scope: Scope;
+}
+interface MigrateContext {
+    key: string;
+    scope: Scope;
+    fromVersion: number;
+    toVersion: number;
+    data: unknown;
+}
+interface QuotaExceededContext {
+    key: string;
+    scope: Scope;
+    error: unknown;
+}
+interface HydrateContext {
+    key: string;
+    scope: Scope;
+    serverValue: unknown;
+    clientValue: unknown;
+}
+interface SyncContext {
+    key: string;
+    scope: Scope;
+    value: unknown;
+    source: 'remote';
+}
+interface RegisterContext {
+    key: string;
+    scope: Scope;
+}
+interface SteadConfig {
+    /** Default scope for all state instances. Defaults to `'render'`. */
+    defaultScope?: Scope | undefined;
+    /** Enforce a naming pattern for state keys. */
+    keyPattern?: RegExp | undefined;
+    /** Control log verbosity for internal warnings and errors. Defaults to `'warn'`. */
+    logLevel?: LogLevel | undefined;
+    /** Cap the total number of registered state instances. */
+    maxKeys?: number | undefined;
+    /** Prepends to all storage keys (e.g. `myapp:theme`) */
+    prefix?: string | undefined;
+    /** Require a validate option for persisted scopes (local, tab, bucket). */
+    requireValidation?: boolean | undefined;
+    /** Enable SSR mode globally for all instances. */
+    ssr?: boolean | undefined;
+    /** Enable cross-tab sync globally for all syncable scopes. */
+    sync?: boolean | undefined;
+    /** Warn when two state() calls use the same key + scope. */
+    warnOnDuplicate?: boolean | undefined;
+    /** Fires when any instance is destroyed. */
+    onDestroy?: ((context: DestroyContext) => void) | undefined;
+    /** Global error handler for storage/migration/validation failures. */
+    onError?: ((context: ErrorContext) => void) | undefined;
+    /** Fires after SSR hydration completes for an instance. */
+    onHydrate?: ((context: HydrateContext) => void) | undefined;
+    /** Fires after a migration chain runs during read. */
+    onMigrate?: ((context: MigrateContext) => void) | undefined;
+    /** Fires when a storage write fails due to quota. */
+    onQuotaExceeded?: ((context: QuotaExceededContext) => void) | undefined;
+    /** Fires when a new state instance is registered. */
+    onRegister?: ((context: RegisterContext) => void) | undefined;
+    /** Fires when a cross-tab sync event updates a value. */
+    onSync?: ((context: SyncContext) => void) | undefined;
+}
+declare function configure(config: SteadConfig): void;
+
+interface WithWatch<T> {
+    /**
+     * Watch a specific key within an object value.
+     * The listener only fires when that key's value changes,
+     * using Object.is for comparison.
+     *
+     * Returns an unsubscribe function.
+     */
+    watch<K extends T extends object ? keyof T : never>(key: K, listener: (value: T[K & keyof T]) => void): Unsubscribe;
+}
+declare function withWatch<TIn extends BaseInstance<any>>(instance: TIn): TIn & WithWatch<TIn extends BaseInstance<infer T> ? T : unknown>;
+
+export { BaseInstance, type DestroyContext, type ErrorContext, type HydrateContext, type LogLevel, type MigrateContext, type QuotaExceededContext, type RegisterContext, Scope, type SteadConfig, type SyncContext, Unsubscribe, type WithWatch, configure, withWatch };

package/dist/index.js

@@ -0,0 +1,3 @@
+export { batch, collection, computed, configure, effect, state, withServerSession, withWatch } from './chunk-347V4L7H.js';
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/react/index.cjs

@@ -0,0 +1,150 @@
+'use strict';
+
+var chunkGGB5QBDR_cjs = require('../chunk-GGB5QBDR.cjs');
+var react = require('react');
+
+function useStore(key, options) {
+  const instance = chunkGGB5QBDR_cjs.state(key, options);
+  const value = react.useSyncExternalStore(
+    react.useCallback((onStoreChange) => instance.subscribe(onStoreChange), [instance]),
+    () => instance.get(),
+    () => options.default
+  );
+  const set = react.useCallback(
+    (valueOrUpdater) => {
+      instance.set(valueOrUpdater);
+    },
+    [instance]
+  );
+  return [value, set];
+}
+function useStateInstance(key, options) {
+  const instance = chunkGGB5QBDR_cjs.state(key, options);
+  react.useSyncExternalStore(
+    react.useCallback((onStoreChange) => instance.subscribe(onStoreChange), [instance]),
+    () => instance.get(),
+    () => options.default
+  );
+  return instance;
+}
+function useSharedState(instance) {
+  const value = react.useSyncExternalStore(
+    react.useCallback((onStoreChange) => instance.subscribe(onStoreChange), [instance]),
+    () => instance.get(),
+    () => instance.get()
+  );
+  const set = react.useCallback(
+    (valueOrUpdater) => {
+      instance.set(valueOrUpdater);
+    },
+    [instance]
+  );
+  return [value, set];
+}
+function useWatch(instance, key) {
+  const getSnapshot = react.useCallback(() => instance.get()[key], [instance, key]);
+  return react.useSyncExternalStore(
+    react.useCallback(
+      (onStoreChange) => {
+        return instance.watch(key, onStoreChange);
+      },
+      [instance, key]
+    ),
+    getSnapshot
+  );
+}
+function useReady(instance) {
+  const [isReady, setIsReady] = react.useState(false);
+  react.useEffect(() => {
+    let cancelled = false;
+    instance.ready.then(() => {
+      if (!cancelled) setIsReady(true);
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [instance]);
+  return isReady;
+}
+function useSettled(instance) {
+  const [isSettled, setIsSettled] = react.useState(false);
+  react.useEffect(() => {
+    let cancelled = false;
+    setIsSettled(false);
+    instance.settled.then(() => {
+      if (!cancelled) setIsSettled(true);
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [instance]);
+  return isSettled;
+}
+function useHydrated(instance) {
+  const [isHydrated, setIsHydrated] = react.useState(false);
+  react.useEffect(() => {
+    let cancelled = false;
+    instance.hydrated.then(() => {
+      if (!cancelled) setIsHydrated(true);
+    }).catch(() => {
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [instance]);
+  return isHydrated;
+}
+function useBucket(key, options) {
+  const mergedOptions = { ...options, scope: "bucket" };
+  const instance = chunkGGB5QBDR_cjs.state(key, mergedOptions);
+  const [value, set] = useStore(key, mergedOptions);
+  const isReady = useReady(instance);
+  return [value, set, isReady];
+}
+function useCollection(key, options) {
+  const col = chunkGGB5QBDR_cjs.collection(key, options);
+  react.useSyncExternalStore(
+    react.useCallback((onStoreChange) => col.subscribe(onStoreChange), [col]),
+    () => col.get(),
+    () => options.default
+  );
+  return col;
+}
+
+Object.defineProperty(exports, "batch", {
+  enumerable: true,
+  get: function () { return chunkGGB5QBDR_cjs.batch; }
+});
+Object.defineProperty(exports, "collection", {
+  enumerable: true,
+  get: function () { return chunkGGB5QBDR_cjs.collection; }
+});
+Object.defineProperty(exports, "computed", {
+  enumerable: true,
+  get: function () { return chunkGGB5QBDR_cjs.computed; }
+});
+Object.defineProperty(exports, "effect", {
+  enumerable: true,
+  get: function () { return chunkGGB5QBDR_cjs.effect; }
+});
+Object.defineProperty(exports, "state", {
+  enumerable: true,
+  get: function () { return chunkGGB5QBDR_cjs.state; }
+});
+Object.defineProperty(exports, "withServerSession", {
+  enumerable: true,
+  get: function () { return chunkGGB5QBDR_cjs.withServerSession; }
+});
+exports.useBucket = useBucket;
+exports.useCollection = useCollection;
+exports.useHydrated = useHydrated;
+exports.useReady = useReady;
+exports.useSettled = useSettled;
+exports.useSharedState = useSharedState;
+exports.useStateInstance = useStateInstance;
+exports.useStore = useStore;
+exports.useWatch = useWatch;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map