seitu 0.14.1 → 0.15.0

package/dist/core.d.mts

@@ -1,2 +1,2 @@
-import { S as createSubscription, _ as Readable, a as Store, b as Writable, c as SchemaStoreOptions, d as createDebouncedFn, f as Debounced, g as Clearable, h as createComputed, i as createThrottled, l as createSchemaStore, m as Computed, n as createThrottledFn, o as createStore, p as createDebounced, r as Throttled, s as SchemaStore, t as ThrottledFn, u as DebouncedFn, v as Subscribable, x as createReadableSubscription, y as SubscribeOptions } from "./index-Dzu3WPwr.mjs";
+import { S as createSubscription, _ as Readable, a as Store, b as Writable, c as SchemaStoreOptions, d as createDebouncedFn, f as Debounced, g as Clearable, h as createComputed, i as createThrottled, l as createSchemaStore, m as Computed, n as createThrottledFn, o as createStore, p as createDebounced, r as Throttled, s as SchemaStore, t as ThrottledFn, u as DebouncedFn, v as Subscribable, x as createReadableSubscription, y as SubscribeOptions } from "./index-DwN8Up-P.mjs";
 export { Clearable, Computed, Debounced, DebouncedFn, Readable, SchemaStore, SchemaStoreOptions, Store, Subscribable, SubscribeOptions, Throttled, ThrottledFn, Writable, createComputed, createDebounced, createDebouncedFn, createReadableSubscription, createSchemaStore, createStore, createSubscription, createThrottled, createThrottledFn };

package/dist/core.mjs

@@ -1,2 +1,2 @@
-import { c as createDebounced, d as createSubscription, i as createSchemaStore, l as createComputed, n as createThrottled, r as createStore, s as createDebouncedFn, t as createThrottledFn, u as createReadableSubscription } from "./core-CwV8yAwb.mjs";
+import { c as createDebounced, d as createSubscription, i as createSchemaStore, l as createComputed, n as createThrottled, r as createStore, s as createDebouncedFn, t as createThrottledFn, u as createReadableSubscription } from "./core-Vbl0ORaj.mjs";
 export { createComputed, createDebounced, createDebouncedFn, createReadableSubscription, createSchemaStore, createStore, createSubscription, createThrottled, createThrottledFn };

package/dist/{index-Dzu3WPwr.d.mts → index-DwN8Up-P.d.mts}

@@ -1,4 +1,4 @@
-import { i as StandardSchemaV1, r as ValidationSchemaOutput, t as ValidationSchemaErrorProps } from "./validate-IWiN_jFZ.mjs";
+import { i as StandardSchemaV1, r as ValidationSchemaOutput, t as ValidationSchemaErrorProps } from "./validate-BYHKInzu.mjs";
 
 //#region src/core/subscription.d.ts
 interface SubscribeOptions {

package/dist/react.d.mts

@@ -1,4 +1,4 @@
-import { _ as Readable, v as Subscribable } from "./index-Dzu3WPwr.mjs";
+import { _ as Readable, v as Subscribable } from "./index-DwN8Up-P.mjs";
 import * as React$1 from "react";
 
 //#region src/react/hooks.d.ts
@@ -159,6 +159,6 @@ declare function Subscription<S extends Subscribable<any> & Readable<any>, R = S
   value,
   selector,
   children
-}: SubscriptionProps<S, R>): React$1.ReactNode;
+}: SubscriptionProps<S, R>): import("react").ReactNode;
 //#endregion
 export { Subscription, SubscriptionProps, UseSubscriptionOptions, useSubscription };

package/dist/utils.d.mts

@@ -1,29 +1,6 @@
-import { t as ValidationSchemaErrorProps } from "./validate-IWiN_jFZ.mjs";
+import { t as ValidationSchemaErrorProps } from "./validate-BYHKInzu.mjs";
 
 //#region src/utils/validation.d.ts
-/**
- * Repair broken web storage value object if value was object but not all keys are in the default value object.
- *
- * @returns A new object with the existing keys in the value object that are not in the default value object.
- *
- * @example
- * ```ts
- * import { createWebStorageValue } from 'seitu/web'
- * import { repairValueObjectWithDefault } from 'seitu/utils'
- * import * as z from 'zod'
- *
- * const value = createWebStorageValue({
- *   type: 'localStorage',
- *   schema: z.object({ a: z.number(), b: z.string() }),
- *   key: 'storage-key',
- *   defaultValue: { a: 0, b: 'default' },
- *   onValidationError: repairValueObjectWithDefault,
- * })
- * value.get() // { a: 0, b: 'default' }
- * window.localStorage.setItem('storage-key', JSON.stringify({ a: 1 }))
- * value.get() // { a: 1, b: 'default' }
- * ```
- */
 declare function repairValueObjectWithDefault<O extends Record<string, unknown>>(props: ValidationSchemaErrorProps<O>): O & {
   [k: string]: any;
 };

package/dist/utils.mjs

@@ -1,2 +1,2 @@
-import { t as repairValueObjectWithDefault } from "./validation-B8XxyKZ0.mjs";
+import { t as repairValueObjectWithDefault } from "./validation-BRHMV4Ky.mjs";
 export { repairValueObjectWithDefault };

package/dist/validation-BRHMV4Ky.mjs

@@ -0,0 +1,9 @@
+//#region src/utils/validation.ts
+function repairValueObjectWithDefault(props) {
+	return {
+		...props.defaultValue,
+		...typeof props.value === "object" && props.value !== null ? Object.fromEntries(Object.entries(props.value).filter(([key, val]) => key in props.defaultValue && typeof val === typeof props.defaultValue[key])) : {}
+	};
+}
+//#endregion
+export { repairValueObjectWithDefault as t };

package/dist/vue.d.mts

@@ -1,4 +1,4 @@
-import { _ as Readable, v as Subscribable } from "./index-Dzu3WPwr.mjs";
+import { _ as Readable, v as Subscribable } from "./index-DwN8Up-P.mjs";
 import { MaybeRefOrGetter, ShallowRef } from "vue";
 
 //#region src/vue/composables.d.ts

package/dist/web.d.mts

@@ -1,6 +1,184 @@
-import { _ as Readable, b as Writable, g as Clearable, v as Subscribable } from "./index-Dzu3WPwr.mjs";
-import { i as StandardSchemaV1, n as ValidationSchemaObjectErrorProps, t as ValidationSchemaErrorProps } from "./validate-IWiN_jFZ.mjs";
+import { _ as Readable, b as Writable, g as Clearable, v as Subscribable } from "./index-DwN8Up-P.mjs";
+import { i as StandardSchemaV1, n as ValidationSchemaObjectErrorProps, t as ValidationSchemaErrorProps } from "./validate-BYHKInzu.mjs";
 
+//#region src/utils.d.ts
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+//#endregion
+//#region src/web/web-storage.d.ts
+type WebStorageInput = Record<string, StandardSchemaV1<unknown, unknown>>;
+type WebStorageOutput<S extends WebStorageInput> = Simplify<{ [K in keyof S]: StandardSchemaV1.InferOutput<S[K]> }>;
+interface WebStorageOptions<S extends WebStorageInput> {
+  schemas: S;
+  defaultValues: WebStorageOutput<S>;
+  type: 'localStorage' | 'sessionStorage';
+  keyTransform?: (key: keyof S) => string;
+  onValidationError?: (props: ValidationSchemaObjectErrorProps<WebStorageOutput<S>>) => void | StandardSchemaV1.InferOutput<S[keyof S]>;
+}
+interface WebStorage<O extends Record<string, unknown>> extends Subscribable<O>, Readable<O>, Writable<Partial<O>, O>, Clearable {
+  '~': {
+    getDefaultValue: <K extends keyof O>(key: K) => O[K];
+    type: 'localStorage' | 'sessionStorage';
+  } & Subscribable<O>['~'];
+}
+/**
+ * Creates a reactive handle for a localStorage or sessionStorage instance.
+ *
+ * @example Vanilla
+ * ```ts twoslash title="session-storage.ts"
+ * import { createWebStorage } from 'seitu/web'
+ * import * as z from 'zod'
+ *
+ * const sessionStorage = createWebStorage({
+ *   type: 'sessionStorage',
+ *   schemas: {
+ *     token: z.string().nullable(),
+ *     preferences: z.object({ theme: z.enum(['light', 'dark']) }),
+ *   },
+ *   defaultValues: { token: null, preferences: { theme: 'light' } },
+ * })
+ *
+ * sessionStorage.get() // { token: null, preferences: { theme: 'light' } }
+ * sessionStorage.set({ token: 'abc' })
+ * sessionStorage.get() // { token: 'abc', preferences: { theme: 'light' } }
+ * sessionStorage.subscribe(console.log)
+ * ```
+ *
+ * @example React
+ * ```tsx twoslash title="page.tsx"
+ * 'use client'
+ *
+ * import { createWebStorage } from 'seitu/web'
+ * import { useSubscription } from 'seitu/react'
+ * import * as z from 'zod'
+ *
+ * const sessionStorage = createWebStorage({
+ *   type: 'sessionStorage',
+ *   schemas: { count: z.number(), name: z.string() },
+ *   defaultValues: { count: 0, name: '' },
+ * })
+ *
+ * export default function Page() {
+ *   const value = useSubscription(sessionStorage)
+ *   return (
+ *     <div>
+ *       <span>{value.count}</span>
+ *       <span>{value.name}</span>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function createWebStorage<S extends WebStorageInput>(options: WebStorageOptions<S>): WebStorage<WebStorageOutput<S>>;
+//#endregion
+//#region src/web/indexed-db-storage.d.ts
+interface IndexedDbStorageOptions<S extends WebStorageInput> {
+  schemas: S;
+  defaultValues: WebStorageOutput<S>;
+  /**
+   * Name of the IndexedDB database to open.
+   */
+  databaseName: string;
+  /**
+   * Name of the object store used to persist values.
+   *
+   * @default 'seitu'
+   */
+  storeName?: string;
+  /**
+   * Version of the IndexedDB database. Leave unset to let the storage manage
+   * the version automatically (it bumps the version when it needs to create
+   * its object store).
+   */
+  version?: number;
+  keyTransform?: (key: keyof S) => string;
+  onValidationError?: (props: ValidationSchemaObjectErrorProps<WebStorageOutput<S>>) => void | StandardSchemaV1.InferOutput<S[keyof S]>;
+}
+interface IndexedDbStorage<O extends Record<string, unknown>> extends Subscribable<O>, Readable<O>, Writable<Partial<O>, O>, Clearable {
+  /**
+   * Resolves once the initial value has been read from IndexedDB.
+   *
+   * Because IndexedDB is asynchronous, `get()` returns the in-memory cache
+   * (the default values until hydration completes). Await `ready` to read the
+   * persisted value. This promise never rejects — read failures fall back to
+   * the default values and are logged.
+   */
+  'ready': Promise<O>;
+  /**
+   * Updates the in-memory cache synchronously (so `get()` reflects the change
+   * immediately) and persists to IndexedDB asynchronously. The returned promise
+   * resolves once persistence settles and never rejects.
+   */
+  'set': (value: Partial<O> | ((prev: O) => Partial<O>)) => Promise<void>;
+  /**
+   * Resets the cache to the default values synchronously and removes the managed
+   * keys from IndexedDB asynchronously. The returned promise resolves once
+   * persistence settles and never rejects.
+   */
+  'clear': () => Promise<void>;
+  '~': {
+    getDefaultValue: <K extends keyof O>(key: K) => O[K];
+    databaseName: string;
+    storeName: string;
+  } & Subscribable<O>['~'];
+}
+/**
+ * Creates a reactive handle for an IndexedDB object store.
+ *
+ * IndexedDB is asynchronous, so the handle keeps an in-memory cache that
+ * `get()` reads synchronously. The cache is hydrated from IndexedDB on
+ * creation (await `ready` to know when), and changes made via `set()` /
+ * `clear()` are persisted asynchronously. When `BroadcastChannel` is
+ * available, changes are synced across tabs while there is at least one
+ * subscriber.
+ *
+ * @example Vanilla
+ * ```ts twoslash title="settings-storage.ts"
+ * import { createIndexedDbStorage } from 'seitu/web'
+ * import * as z from 'zod'
+ *
+ * const settingsStorage = createIndexedDbStorage({
+ *   databaseName: 'app',
+ *   schemas: {
+ *     token: z.string().nullable(),
+ *     preferences: z.object({ theme: z.enum(['light', 'dark']) }),
+ *   },
+ *   defaultValues: { token: null, preferences: { theme: 'light' } },
+ * })
+ *
+ * settingsStorage.get() // { token: null, preferences: { theme: 'light' } }
+ * await settingsStorage.ready // value hydrated from IndexedDB
+ * await settingsStorage.set({ token: 'abc' })
+ * settingsStorage.get() // { token: 'abc', preferences: { theme: 'light' } }
+ * settingsStorage.subscribe(console.log)
+ * ```
+ *
+ * @example React
+ * ```tsx twoslash title="page.tsx"
+ * 'use client'
+ *
+ * import { createIndexedDbStorage } from 'seitu/web'
+ * import { useSubscription } from 'seitu/react'
+ * import * as z from 'zod'
+ *
+ * const settingsStorage = createIndexedDbStorage({
+ *   databaseName: 'app',
+ *   schemas: { count: z.number(), name: z.string() },
+ *   defaultValues: { count: 0, name: '' },
+ * })
+ *
+ * export default function Page() {
+ *   const value = useSubscription(settingsStorage)
+ *   return (
+ *     <div>
+ *       <span>{value.count}</span>
+ *       <span>{value.name}</span>
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function createIndexedDbStorage<S extends WebStorageInput>(options: IndexedDbStorageOptions<S>): IndexedDbStorage<WebStorageOutput<S>>;
+//#endregion
 //#region src/web/is-online.d.ts
 interface IsOnline extends Subscribable<boolean>, Readable<boolean> {}
 /**
@@ -221,75 +399,6 @@ interface ScrollStateOptions {
  */
 declare function createScrollState(options: ScrollStateOptions): ScrollState;
 //#endregion
-//#region src/utils.d.ts
-type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
-//#endregion
-//#region src/web/web-storage.d.ts
-type WebStorageInput = Record<string, StandardSchemaV1<unknown, unknown>>;
-type WebStorageOutput<S extends WebStorageInput> = Simplify<{ [K in keyof S]: StandardSchemaV1.InferOutput<S[K]> }>;
-interface WebStorageOptions<S extends WebStorageInput> {
-  schemas: S;
-  defaultValues: WebStorageOutput<S>;
-  type: 'localStorage' | 'sessionStorage';
-  keyTransform?: (key: keyof S) => string;
-  onValidationError?: (props: ValidationSchemaObjectErrorProps<WebStorageOutput<S>>) => void | StandardSchemaV1.InferOutput<S[keyof S]>;
-}
-interface WebStorage<O extends Record<string, unknown>> extends Subscribable<O>, Readable<O>, Writable<Partial<O>, O>, Clearable {
-  '~': {
-    getDefaultValue: <K extends keyof O>(key: K) => O[K];
-    type: 'localStorage' | 'sessionStorage';
-  } & Subscribable<O>['~'];
-}
-/**
- * Creates a reactive handle for a localStorage or sessionStorage instance.
- *
- * @example Vanilla
- * ```ts twoslash title="session-storage.ts"
- * import { createWebStorage } from 'seitu/web'
- * import * as z from 'zod'
- *
- * const sessionStorage = createWebStorage({
- *   type: 'sessionStorage',
- *   schemas: {
- *     token: z.string().nullable(),
- *     preferences: z.object({ theme: z.enum(['light', 'dark']) }),
- *   },
- *   defaultValues: { token: null, preferences: { theme: 'light' } },
- * })
- *
- * sessionStorage.get() // { token: null, preferences: { theme: 'light' } }
- * sessionStorage.set({ token: 'abc' })
- * sessionStorage.get() // { token: 'abc', preferences: { theme: 'light' } }
- * sessionStorage.subscribe(console.log)
- * ```
- *
- * @example React
- * ```tsx twoslash title="page.tsx"
- * 'use client'
- *
- * import { createWebStorage } from 'seitu/web'
- * import { useSubscription } from 'seitu/react'
- * import * as z from 'zod'
- *
- * const sessionStorage = createWebStorage({
- *   type: 'sessionStorage',
- *   schemas: { count: z.number(), name: z.string() },
- *   defaultValues: { count: 0, name: '' },
- * })
- *
- * export default function Page() {
- *   const value = useSubscription(sessionStorage)
- *   return (
- *     <div>
- *       <span>{value.count}</span>
- *       <span>{value.name}</span>
- *     </div>
- *   )
- * }
- * ```
- */
-declare function createWebStorage<S extends WebStorageInput>(options: WebStorageOptions<S>): WebStorage<WebStorageOutput<S>>;
-//#endregion
 //#region src/web/web-storage-value.d.ts
 interface WebStorageValue<V> extends Subscribable<V>, Readable<V>, Writable<V>, Clearable {}
 interface WebStorageValueOptionsWithStorage<Storage extends WebStorage<any>, K extends keyof Storage['~']['output']> {
@@ -380,4 +489,4 @@ interface WebStorageValueOptionsWithSchema<S extends StandardSchemaV1<unknown>>
 declare function createWebStorageValue<Storage extends WebStorage<any>, K extends keyof Storage['~']['output']>(options: WebStorageValueOptionsWithStorage<Storage, K>): WebStorageValue<Storage['~']['output'][K]>;
 declare function createWebStorageValue<S extends StandardSchemaV1<unknown>>(options: WebStorageValueOptionsWithSchema<S>): WebStorageValue<StandardSchemaV1.InferOutput<S>>;
 //#endregion
-export { IsOnline, MediaQuery, MediaQueryOptions, MediaQueryType, ScrollDirection, ScrollState, ScrollStateEdge, ScrollStateOptions, ScrollStateThreshold, ScrollStateValue, WebStorage, WebStorageInput, WebStorageOptions, WebStorageOutput, WebStorageValue, WebStorageValueOptionsWithSchema, WebStorageValueOptionsWithStorage, createIsOnline, createMediaQuery, createScrollState, createWebStorage, createWebStorageValue };
+export { IndexedDbStorage, IndexedDbStorageOptions, IsOnline, MediaQuery, MediaQueryOptions, MediaQueryType, ScrollDirection, ScrollState, ScrollStateEdge, ScrollStateOptions, ScrollStateThreshold, ScrollStateValue, WebStorage, WebStorageInput, WebStorageOptions, WebStorageOutput, WebStorageValue, WebStorageValueOptionsWithSchema, WebStorageValueOptionsWithStorage, createIndexedDbStorage, createIsOnline, createMediaQuery, createScrollState, createWebStorage, createWebStorageValue };

package/dist/web.mjs

@@ -1,5 +1,229 @@
-import { a as validateSchema, d as createSubscription, o as tryParseJson, u as createReadableSubscription } from "./core-CwV8yAwb.mjs";
-import { t as repairValueObjectWithDefault } from "./validation-B8XxyKZ0.mjs";
+import { a as validateSchema, d as createSubscription, o as tryParseJson, u as createReadableSubscription } from "./core-Vbl0ORaj.mjs";
+import { t as repairValueObjectWithDefault } from "./validation-BRHMV4Ky.mjs";
+import { deepEqual } from "fast-equals";
+//#region src/web/indexed-db-storage.ts
+function requestToPromise(request) {
+	return new Promise((resolve, reject) => {
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error);
+	});
+}
+function transactionDone(transaction) {
+	return new Promise((resolve, reject) => {
+		transaction.oncomplete = () => resolve();
+		transaction.onerror = () => reject(transaction.error);
+		transaction.onabort = () => reject(transaction.error);
+	});
+}
+function openRequest(name, version, storeName) {
+	return new Promise((resolve, reject) => {
+		const request = version === void 0 ? indexedDB.open(name) : indexedDB.open(name, version);
+		request.onupgradeneeded = () => {
+			const db = request.result;
+			if (!db.objectStoreNames.contains(storeName)) db.createObjectStore(storeName);
+		};
+		request.onsuccess = () => resolve(request.result);
+		request.onerror = () => reject(request.error);
+	});
+}
+async function openDatabase(name, storeName, version) {
+	const db = await openRequest(name, version, storeName);
+	if (db.objectStoreNames.contains(storeName)) return db;
+	if (version !== void 0) return db;
+	const nextVersion = db.version + 1;
+	db.close();
+	return openRequest(name, nextVersion, storeName);
+}
+/**
+* Creates a reactive handle for an IndexedDB object store.
+*
+* IndexedDB is asynchronous, so the handle keeps an in-memory cache that
+* `get()` reads synchronously. The cache is hydrated from IndexedDB on
+* creation (await `ready` to know when), and changes made via `set()` /
+* `clear()` are persisted asynchronously. When `BroadcastChannel` is
+* available, changes are synced across tabs while there is at least one
+* subscriber.
+*
+* @example Vanilla
+* ```ts twoslash title="settings-storage.ts"
+* import { createIndexedDbStorage } from 'seitu/web'
+* import * as z from 'zod'
+*
+* const settingsStorage = createIndexedDbStorage({
+*   databaseName: 'app',
+*   schemas: {
+*     token: z.string().nullable(),
+*     preferences: z.object({ theme: z.enum(['light', 'dark']) }),
+*   },
+*   defaultValues: { token: null, preferences: { theme: 'light' } },
+* })
+*
+* settingsStorage.get() // { token: null, preferences: { theme: 'light' } }
+* await settingsStorage.ready // value hydrated from IndexedDB
+* await settingsStorage.set({ token: 'abc' })
+* settingsStorage.get() // { token: 'abc', preferences: { theme: 'light' } }
+* settingsStorage.subscribe(console.log)
+* ```
+*
+* @example React
+* ```tsx twoslash title="page.tsx"
+* 'use client'
+*
+* import { createIndexedDbStorage } from 'seitu/web'
+* import { useSubscription } from 'seitu/react'
+* import * as z from 'zod'
+*
+* const settingsStorage = createIndexedDbStorage({
+*   databaseName: 'app',
+*   schemas: { count: z.number(), name: z.string() },
+*   defaultValues: { count: 0, name: '' },
+* })
+*
+* export default function Page() {
+*   const value = useSubscription(settingsStorage)
+*   return (
+*     <div>
+*       <span>{value.count}</span>
+*       <span>{value.name}</span>
+*     </div>
+*   )
+* }
+* ```
+*/
+function createIndexedDbStorage(options) {
+	const defaultValues = { ...options.defaultValues };
+	const storeName = options.storeName ?? "seitu";
+	const keys = Object.keys(options.defaultValues);
+	const isSupported = typeof indexedDB !== "undefined";
+	const channelName = `seitu:indexed-db:${options.databaseName}:${storeName}`;
+	const label = `createIndexedDbStorage:${options.databaseName}/${storeName}`;
+	const resolveKey = (key) => String(options.keyTransform ? options.keyTransform(key) : key);
+	let cache = { ...options.defaultValues };
+	let writeVersion = 0;
+	const keyWriteVersion = /* @__PURE__ */ new Map();
+	let hydrateSeq = 0;
+	const markWritten = (written) => {
+		writeVersion++;
+		for (const key of written) keyWriteVersion.set(key, writeVersion);
+	};
+	let channel;
+	let triggerHydrate = () => {};
+	const broadcast = () => {
+		if (typeof BroadcastChannel === "undefined") return;
+		if (channel) {
+			channel.postMessage(null);
+			return;
+		}
+		const ephemeral = new BroadcastChannel(channelName);
+		ephemeral.postMessage(null);
+		ephemeral.close();
+	};
+	let dbPromise;
+	const getDatabase = () => {
+		if (!dbPromise) dbPromise = openDatabase(options.databaseName, storeName, options.version).then((db) => {
+			db.onversionchange = () => {
+				db.close();
+				dbPromise = void 0;
+			};
+			return db;
+		}).catch((error) => {
+			dbPromise = void 0;
+			throw error;
+		});
+		return dbPromise;
+	};
+	const { subscribe, notify } = createSubscription({ onFirstSubscribe: () => {
+		triggerHydrate();
+		if (typeof BroadcastChannel === "undefined") return;
+		channel = new BroadcastChannel(channelName);
+		channel.onmessage = () => triggerHydrate();
+		return () => {
+			channel?.close();
+			channel = void 0;
+		};
+	} });
+	const validateValue = (key, raw) => {
+		if (raw === void 0) return options.defaultValues[key];
+		return validateSchema(options.schemas[key], raw, {
+			defaultValue: options.defaultValues[key],
+			label: `createIndexedDbStorage:${String(key)}`,
+			onError: options.onValidationError ? (issues, parsed) => options.onValidationError({
+				issues: [...issues],
+				key,
+				value: parsed,
+				defaultValue: options.defaultValues[key]
+			}) : void 0
+		});
+	};
+	const hydrate = async () => {
+		if (!isSupported) return cache;
+		const seq = ++hydrateSeq;
+		const startVersion = writeVersion;
+		const store = (await getDatabase()).transaction(storeName, "readonly").objectStore(storeName);
+		const persisted = {};
+		await Promise.all(keys.map(async (key) => {
+			persisted[key] = validateValue(key, await requestToPromise(store.get(resolveKey(key))));
+		}));
+		if (seq !== hydrateSeq) return cache;
+		const next = {};
+		for (const key of keys) next[key] = (keyWriteVersion.get(key) ?? 0) > startVersion ? cache[key] : persisted[key];
+		if (!deepEqual(cache, next)) {
+			cache = next;
+			notify();
+		}
+		return cache;
+	};
+	const safeHydrate = () => hydrate().catch((error) => {
+		console.warn(`[${label}] Failed to read from IndexedDB, using cached values.`, error);
+		return cache;
+	});
+	triggerHydrate = () => void safeHydrate();
+	const ready = safeHydrate();
+	const get = () => cache;
+	const readable = createReadableSubscription(get, subscribe, notify);
+	const persist = async (mutate) => {
+		if (!isSupported) return;
+		try {
+			const transaction = (await getDatabase()).transaction(storeName, "readwrite");
+			mutate(transaction.objectStore(storeName));
+			await transactionDone(transaction);
+			broadcast();
+		} catch (error) {
+			console.warn(`[${label}] Failed to write to IndexedDB.`, error);
+		}
+	};
+	return {
+		...readable,
+		ready,
+		"set": (value) => {
+			const resolved = typeof value === "function" ? value(cache) : value;
+			markWritten(Object.keys(resolved));
+			cache = {
+				...cache,
+				...resolved
+			};
+			notify();
+			return persist((store) => {
+				for (const [key, entry] of Object.entries(resolved)) store.put(entry, resolveKey(key));
+			});
+		},
+		"clear": () => {
+			markWritten(keys);
+			cache = { ...options.defaultValues };
+			notify();
+			return persist((store) => {
+				for (const key of keys) store.delete(resolveKey(key));
+			});
+		},
+		"~": {
+			...readable["~"],
+			getDefaultValue: (key) => defaultValues[key],
+			databaseName: options.databaseName,
+			storeName
+		}
+	};
+}
+//#endregion
 //#region src/web/is-online.ts
 /**
 * Creates a reactive handle for browser online status.
@@ -458,4 +682,4 @@ function createWebStorageValue(options) {
 	};
 }
 //#endregion
-export { createIsOnline, createMediaQuery, createScrollState, createWebStorage, createWebStorageValue };
+export { createIndexedDbStorage, createIsOnline, createMediaQuery, createScrollState, createWebStorage, createWebStorageValue };

package/package.json

@@ -2,7 +2,7 @@
   "name": "seitu",
   "displayName": "Seitu",
   "type": "module",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "private": false,
   "author": "Valerii Strilets",
   "license": "MIT",
@@ -48,7 +48,8 @@
   "main": "./dist/core.mjs",
   "types": "./dist/core/index.d.mts",
   "files": [
-    "dist"
+    "dist",
+    "skills"
   ],
   "engines": {
     "node": ">=22"
@@ -76,21 +77,23 @@
     "@standard-schema/spec": "^1.1.0",
     "@testing-library/jest-dom": "^6.9.1",
     "@testing-library/react": "^16.3.2",
-    "@types/react": "^19.2.14",
-    "happy-dom": "^20.9.0",
-    "react-dom": "^19.2.6",
-    "tsdown": "^0.22.0",
-    "type-fest": "^5.6.0",
+    "@types/react": "^19.2.17",
+    "fake-indexeddb": "^6.2.5",
+    "happy-dom": "^20.10.2",
+    "react-dom": "^19.2.7",
+    "tsdown": "^0.22.2",
+    "type-fest": "^5.7.0",
     "typescript": "^6.0.3",
-    "vite": "^8.0.13",
-    "vitest": "^4.1.6",
-    "vue": "^3.5.34",
+    "vite": "^6.4.3",
+    "vitest": "^3.2.6",
+    "vue": "^3.5.35",
     "zod": "^4.4.3"
   },
   "scripts": {
     "build": "tsdown",
     "test": "vitest run",
     "check-types": "tsc",
-    "scripts:copy-readme": "node ./scripts/copy-readme.ts"
+    "scripts:copy-readme": "node ./scripts/copy-readme.ts",
+    "scripts:copy-skills": "node ./scripts/copy-skills.ts"
   }
 }

package/skills/Subscription-react/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: Subscription-react
+description: >-
+  Declarative React component for subscribing to Seitu reactive values via
+  render props. Use when you prefer a component API over the useSubscription hook.
+---
+
+# Subscription (React component)
+
+Declarative render-prop component from `seitu/react`. Isolates re-renders to the children function.
+
+```tsx
+import { Subscription } from 'seitu/react'
+
+<Subscription value={storage}>
+  {(value) => <div>{value.count}</div>}
+</Subscription>
+
+<Subscription value={storage} selector={v => v.count}>
+  {(count) => <div>{count}</div>}
+</Subscription>
+```
+
+## Props
+
+| Prop | Type | Description |
+|------|------|-------------|
+| `value` | `Subscribable & Readable` | The reactive source |
+| `selector?` | `(value) => R` | Optional selector for granular updates |
+| `children` | `(value) => ReactNode` | Render function |
+
+## Source
+
+`seitu/src/react/components.tsx`