@k8ordo/state 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Koki Sakano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/entry/codec.d.mts

@@ -0,0 +1,18 @@
+import { StateSchema, StateValues } from "../schema/object.mjs";
+//#region src/entry/codec.d.ts
+type StoredCodec = {
+  keys: readonly string[];
+  defaults: Readonly<StateValues>;
+  parse: (stored: unknown) => StateValues;
+  /** Runs already-typed values through the schema, salvage included. */
+  salvage: (values: Readonly<StateValues>) => StateValues;
+};
+/**
+ * The read side shared by every slot that stores typed values (history entry
+ * state, localStorage JSON): no string serialization to derive — only care
+ * that what comes back may have been written by an older schema, or by
+ * nobody.
+ */
+declare const createStoredCodec: (schema: StateSchema, slot: string) => StoredCodec;
+//#endregion
+export { StoredCodec, createStoredCodec };

package/dist/entry/codec.mjs

@@ -0,0 +1,31 @@
+import { analyzeSchema, isRecord, parseWithSalvage } from "../schema/object.mjs";
+//#region src/entry/codec.ts
+/**
+* The read side shared by every slot that stores typed values (history entry
+* state, localStorage JSON): no string serialization to derive — only care
+* that what comes back may have been written by an older schema, or by
+* nobody.
+*/
+const createStoredCodec = (schema, slot) => {
+	const info = analyzeSchema(schema, slot);
+	const parse = (stored) => {
+		const raw = {};
+		if (isRecord(stored)) {
+			for (const key of info.keys) if (key in stored) raw[key] = stored[key];
+		}
+		return parseWithSalvage(info, raw);
+	};
+	const salvage = (values) => {
+		const own = {};
+		for (const key of info.keys) if (key in values) own[key] = values[key];
+		return parseWithSalvage(info, own);
+	};
+	return {
+		keys: info.keys,
+		defaults: info.defaults,
+		parse,
+		salvage
+	};
+};
+//#endregion
+export { createStoredCodec };

package/dist/index.d.mts

@@ -0,0 +1,11 @@
+import { StateSchema } from "./schema/object.mjs";
+import { Register, RegisteredPath } from "./register.mjs";
+import { UrlInput } from "./url/codec.mjs";
+import { OutputOf, PageState, definePageState } from "./page-state.mjs";
+import { LocalState, defineLocalState } from "./local-state.mjs";
+import { MemoryState, defineMemoryState } from "./memory-state.mjs";
+import { UpdateHandle } from "./store/core.mjs";
+import { UpdateOptions } from "./store/page-store.mjs";
+import { AnyState, useAppState } from "./use-app-state.mjs";
+import { resetStateRegistry } from "./store/registry.mjs";
+export { type AnyState, type LocalState, type MemoryState, type OutputOf, type PageState, type Register, type RegisteredPath, type StateSchema, type UpdateHandle, type UpdateOptions, type UrlInput, defineLocalState, defineMemoryState, definePageState, resetStateRegistry, useAppState };

package/dist/index.mjs

@@ -0,0 +1,6 @@
+import { definePageState } from "./page-state.mjs";
+import { defineLocalState } from "./local-state.mjs";
+import { defineMemoryState } from "./memory-state.mjs";
+import { resetStateRegistry } from "./store/registry.mjs";
+import { useAppState } from "./use-app-state.mjs";
+export { defineLocalState, defineMemoryState, definePageState, resetStateRegistry, useAppState };

package/dist/local-state.d.mts

@@ -0,0 +1,19 @@
+import { StateSchema } from "./schema/object.mjs";
+import { StoredCodec } from "./entry/codec.mjs";
+//#region src/local-state.d.ts
+/**
+ * App-scope state that lives in localStorage: device-persistent, shared
+ * across tabs, never page-bound — which is why it is its own definition kind
+ * instead of a slot on a page state.
+ */
+type LocalState<Schema extends StateSchema = StateSchema> = {
+  kind: 'local';
+  /** Identity of this state: the storage key and the store registry slot. */
+  key: string;
+  /** The schema as passed. */
+  schema: Schema;
+};
+declare const localCodecOf: (def: LocalState) => StoredCodec;
+declare const defineLocalState: <Schema extends StateSchema>(key: string, schema: Schema) => LocalState<Schema>;
+//#endregion
+export { LocalState, defineLocalState, localCodecOf };

package/dist/local-state.mjs

@@ -0,0 +1,19 @@
+import { createStoredCodec } from "./entry/codec.mjs";
+//#region src/local-state.ts
+const codecs = /* @__PURE__ */ new WeakMap();
+const localCodecOf = (def) => {
+	const codec = codecs.get(def);
+	if (codec === void 0) throw new TypeError(`"${def.key}" was not created by defineLocalState of this module instance`);
+	return codec;
+};
+const defineLocalState = (key, schema) => {
+	const def = {
+		kind: "local",
+		key,
+		schema
+	};
+	codecs.set(def, createStoredCodec(schema, "local"));
+	return def;
+};
+//#endregion
+export { defineLocalState, localCodecOf };

package/dist/memory-state.d.mts

@@ -0,0 +1,17 @@
+import { StateValues } from "./schema/object.mjs";
+//#region src/memory-state.d.ts
+/**
+ * A typed shared box that lives for the JS runtime and resets on reload.
+ * The one kind with no schema: its values never leave the runtime, so there
+ * is no boundary to re-validate at — a typed `update` is the only writer.
+ */
+type MemoryState<Values extends StateValues = StateValues> = {
+  kind: 'memory';
+  /** Identity of this state: the store registry slot. */
+  key: string;
+  /** The initial values; also what SSR renders. */
+  initial: Readonly<Values>;
+};
+declare const defineMemoryState: <Values extends StateValues>(key: string, initial: Values) => MemoryState<Values>;
+//#endregion
+export { MemoryState, defineMemoryState };

package/dist/memory-state.mjs

@@ -0,0 +1,8 @@
+//#region src/memory-state.ts
+const defineMemoryState = (key, initial) => ({
+	kind: "memory",
+	key,
+	initial: { ...initial }
+});
+//#endregion
+export { defineMemoryState };

package/dist/page-state.d.mts

@@ -0,0 +1,53 @@
+import { StateSchema } from "./schema/object.mjs";
+import { StoredCodec } from "./entry/codec.mjs";
+import { RegisteredPath } from "./register.mjs";
+import { UrlCodec, UrlInput } from "./url/codec.mjs";
+import { output } from "zod/v4/core";
+//#region src/page-state.d.ts
+type OutputOf<Schema> = Schema extends StateSchema ? output<Schema> : Record<never, never>;
+type PageState<Url extends StateSchema | undefined = StateSchema | undefined, Entry extends StateSchema | undefined = StateSchema | undefined> = {
+  kind: 'page';
+  /** Identity of this state: store registry slot, entry-state namespace. */
+  key: string;
+  /** The url schema as passed — feed it to `@k8ordo/form` for GET forms. */
+  url: Url;
+  /** The entry schema as passed. */
+  entry: Entry;
+  /** Reads the url slot on the server. Absent params get their defaults. */
+  parseUrl: (input: UrlInput) => OutputOf<Url>;
+  /**
+   * Builds a link. Unspecified fields mean their default and defaults are
+   * omitted from the query, so canonical URLs stay short. The path literal
+   * survives in the type, which is what lets typed-route checks pass.
+   */
+  href: <Path extends RegisteredPath>(base: Path, values?: Readonly<Partial<OutputOf<Url>>>) => Path | `${Path}?${string}`;
+  /** The query string alone (no `?`), for handrolled URL composition. */
+  search: (values?: Readonly<Partial<OutputOf<Url>>>) => string;
+};
+type SharedKeys<Url, Entry> = Extract<keyof OutputOf<Url>, keyof OutputOf<Entry>> & string;
+/**
+ * The flat merged state cannot host one name twice; when it would, the error
+ * carries the offending field name instead of a bare "not assignable".
+ */
+type DisjointGuard<Url, Entry> = SharedKeys<Url, Entry> extends never ? unknown : {
+  entry: `field declared in both url and entry: ${SharedKeys<Url, Entry>}`;
+};
+type PageInternals = {
+  url: UrlCodec | null;
+  entry: StoredCodec | null;
+  /** url keys first, then entry keys — the flat snapshot's full key set. */
+  keys: readonly string[];
+};
+declare const internalsOf: (def: PageState) => PageInternals;
+declare function definePageState<Url extends StateSchema>(key: string, config: {
+  url: Url;
+}): PageState<Url, undefined>;
+declare function definePageState<Entry extends StateSchema>(key: string, config: {
+  entry: Entry;
+}): PageState<undefined, Entry>;
+declare function definePageState<Url extends StateSchema, Entry extends StateSchema>(key: string, config: {
+  url: Url;
+  entry: Entry;
+} & DisjointGuard<Url, Entry>): PageState<Url, Entry>;
+//#endregion
+export { OutputOf, PageInternals, PageState, definePageState, internalsOf };

package/dist/page-state.mjs

@@ -0,0 +1,37 @@
+import { createStoredCodec } from "./entry/codec.mjs";
+import { createUrlCodec } from "./url/codec.mjs";
+//#region src/page-state.ts
+const internals = /* @__PURE__ */ new WeakMap();
+const internalsOf = (def) => {
+	const found = internals.get(def);
+	if (found === void 0) throw new TypeError(`"${def.key}" was not created by definePageState of this module instance`);
+	return found;
+};
+function definePageState(key, config) {
+	const url = config.url === void 0 ? null : createUrlCodec(config.url);
+	const entry = config.entry === void 0 ? null : createStoredCodec(config.entry, "entry");
+	if (url === null && entry === null) throw new TypeError(`"${key}" declares neither url nor entry`);
+	const shared = url === null || entry === null ? [] : url.keys.filter((field) => entry.keys.includes(field));
+	if (shared.length > 0) throw new TypeError(`"${key}" declares in both url and entry: ${shared.join(", ")}`);
+	const search = (values) => url === null ? "" : url.search(values ?? {});
+	const def = {
+		kind: "page",
+		key,
+		url: config.url,
+		entry: config.entry,
+		parseUrl: (input) => url === null ? {} : url.parse(input),
+		search,
+		href: (base, values) => {
+			const query = search(values);
+			return query === "" ? base : `${base}?${query}`;
+		}
+	};
+	internals.set(def, {
+		url,
+		entry,
+		keys: [...url?.keys ?? [], ...entry?.keys ?? []]
+	});
+	return def;
+}
+//#endregion
+export { definePageState, internalsOf };

package/dist/register.d.mts

@@ -0,0 +1,22 @@
+//#region src/register.d.ts
+/**
+ * The app-side hook for typed route paths. An application augments this once:
+ *
+ * ```ts
+ * import type { Route } from 'next';
+ * declare module '@k8ordo/state' {
+ *   interface Register { path: Route }
+ * }
+ * ```
+ *
+ * and every `href()` in the app is constrained to its router's route type.
+ * Declared as an interface — the one exception to the repository's type-only
+ * rule — because declaration merging is the entire mechanism.
+ */
+interface Register {}
+/** `href()`'s path constraint: the registered route type, or any `/`-path. */
+type RegisteredPath = Register extends {
+  path: infer P extends string;
+} ? P : `/${string}`;
+//#endregion
+export { Register, RegisteredPath };

package/dist/register.mjs

@@ -0,0 +1 @@
+export {};

package/dist/schema/object.d.mts

@@ -0,0 +1,35 @@
+import { $ZodObject, $ZodShape, $ZodType } from "zod/v4/core";
+//#region src/schema/object.d.ts
+/**
+ * The common ground between `zod` and `zod/mini`: both build on the shared
+ * core object and both expose `shape`. Accepting this keeps the smaller entry
+ * usable without losing the types.
+ */
+type StateSchema<Shape extends $ZodShape = $ZodShape> = $ZodObject<Shape> & {
+  shape: Shape;
+};
+type StateValues = Record<string, unknown>;
+type SchemaInfo = {
+  schema: StateSchema;
+  shape: Readonly<Record<string, $ZodType>>;
+  keys: readonly string[];
+  defaults: Readonly<StateValues>;
+};
+declare const isRecord: (value: unknown) => value is StateValues;
+/**
+ * Structural equality over what schemas produce: scalars via `Object.is`,
+ * arrays and plain objects recursively. Anything else (Date, Map, class
+ * instances) compares by reference only — conservatively "changed" — because
+ * two structurally silent objects can still differ (a Date's time lives in
+ * an internal slot, not in enumerable keys).
+ */
+declare const sameValue: (a: unknown, b: unknown) => boolean;
+declare const analyzeSchema: (schema: StateSchema, slot: string) => SchemaInfo;
+/**
+ * Whole-parse first; when that fails, the values are user-editable or stale
+ * input, so one broken field falls back to its own default instead of taking
+ * the rest down with it.
+ */
+declare const parseWithSalvage: (info: SchemaInfo, raw: StateValues) => StateValues;
+//#endregion
+export { SchemaInfo, StateSchema, StateValues, analyzeSchema, isRecord, parseWithSalvage, sameValue };

package/dist/schema/object.mjs

@@ -0,0 +1,63 @@
+import { safeParse } from "zod/v4/core";
+//#region src/schema/object.ts
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isPlainRecord = (value) => {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+};
+/**
+* Structural equality over what schemas produce: scalars via `Object.is`,
+* arrays and plain objects recursively. Anything else (Date, Map, class
+* instances) compares by reference only — conservatively "changed" — because
+* two structurally silent objects can still differ (a Date's time lives in
+* an internal slot, not in enumerable keys).
+*/
+const sameValue = (a, b) => {
+	if (Object.is(a, b)) return true;
+	if (Array.isArray(a) && Array.isArray(b)) return a.length === b.length && a.every((value, index) => sameValue(value, b[index]));
+	if (isPlainRecord(a) && isPlainRecord(b)) {
+		const aKeys = Object.keys(a);
+		const bKeys = Object.keys(b);
+		return aKeys.length === bKeys.length && aKeys.every((key) => key in b && sameValue(a[key], b[key]));
+	}
+	return false;
+};
+const analyzeSchema = (schema, slot) => {
+	const shape = schema.shape;
+	const keys = Object.keys(shape);
+	const empty = safeParse(schema, {});
+	if (!empty.success) {
+		const failing = keys.filter((key) => !safeParse(shape[key], void 0).success);
+		throw new TypeError(failing.length > 0 ? `${slot} fields must tolerate absence — add .default() or .optional() to: ${failing.join(", ")}` : `${slot} schema rejects its own defaults — an object-level refine must accept the all-defaults value`);
+	}
+	const defaults = {};
+	for (const key of keys) defaults[key] = empty.data[key];
+	return {
+		schema,
+		shape,
+		keys,
+		defaults
+	};
+};
+/**
+* Whole-parse first; when that fails, the values are user-editable or stale
+* input, so one broken field falls back to its own default instead of taking
+* the rest down with it.
+*/
+const parseWithSalvage = (info, raw) => {
+	const whole = safeParse(info.schema, raw);
+	if (whole.success) {
+		const values = {};
+		for (const key of info.keys) values[key] = whole.data[key];
+		return values;
+	}
+	const salvaged = {};
+	for (const key of info.keys) if (key in raw) {
+		const field = safeParse(info.shape[key], raw[key]);
+		salvaged[key] = field.success ? field.data : info.defaults[key];
+	} else salvaged[key] = info.defaults[key];
+	return safeParse(info.schema, salvaged).success ? salvaged : { ...info.defaults };
+};
+//#endregion
+export { analyzeSchema, isRecord, parseWithSalvage, sameValue };

package/dist/store/core.d.mts

@@ -0,0 +1,54 @@
+import { StateValues } from "../schema/object.mjs";
+//#region src/store/core.d.ts
+/**
+ * Mirrors `navigation.navigate()`'s own return shape: an object holding the
+ * promises rather than a promise, so fire-and-forget callers ignore it
+ * without tripping no-floating-promises, and the 5% that await pick a stage.
+ * Slots with no navigation behind them return both promises pre-settled —
+ * the type stays uniform across every kind of state.
+ */
+type UpdateHandle = {
+  /** The write is in its home (history entry, storage, memory). */
+  committed: Promise<void>;
+  /** All downstream work (a router's intercept fetch/render) is done. */
+  finished: Promise<void>;
+};
+type Patch = StateValues | ((current: StateValues) => StateValues);
+type Store = {
+  subscribe: (keys: readonly string[] | null, notify: () => void) => () => void;
+  getSnapshot: (sig: string, keys: readonly string[] | null) => StateValues;
+  update: (patch: Patch, options?: {
+    history?: 'push' | 'replace';
+  }) => UpdateHandle;
+  dispose: () => void;
+};
+type Handle = {
+  external: UpdateHandle;
+  settle: () => void;
+  fail: (error: unknown) => void;
+  adopt: (result: {
+    committed?: Promise<unknown> | undefined;
+    finished?: Promise<unknown> | undefined;
+  }) => void;
+};
+declare const createHandle: () => Handle;
+type StoreCore = {
+  snapshot: () => StateValues;
+  applyNext: (next: StateValues) => void;
+  subscribe: Store['subscribe'];
+  getSnapshot: Store['getSnapshot'];
+  clear: () => void;
+};
+/**
+ * The shared half of every store: an immutable snapshot over a fixed key set,
+ * exact per-key change detection, and notification only to the listeners
+ * whose subscribed keys actually changed.
+ */
+declare const createStoreCore: (keys: readonly string[], initial: StateValues) => StoreCore;
+/**
+ * The unknown-field guard every store shares: the typed API already prevents
+ * this, so reaching it means an untyped caller — fail loudly, not silently.
+ */
+declare const resolvePatch: (patch: Patch, current: StateValues, keys: readonly string[], label: string) => StateValues;
+//#endregion
+export { Handle, Patch, Store, StoreCore, UpdateHandle, createHandle, createStoreCore, resolvePatch };

package/dist/store/core.mjs

@@ -0,0 +1,106 @@
+import { sameValue } from "../schema/object.mjs";
+//#region src/store/core.ts
+const createHandle = () => {
+	let resolveCommitted;
+	let rejectCommitted;
+	let resolveFinished;
+	let rejectFinished;
+	const committed = new Promise((resolve, reject) => {
+		resolveCommitted = resolve;
+		rejectCommitted = reject;
+	});
+	const finished = new Promise((resolve, reject) => {
+		resolveFinished = resolve;
+		rejectFinished = reject;
+	});
+	committed.catch(() => void 0);
+	finished.catch(() => void 0);
+	return {
+		external: {
+			committed,
+			finished
+		},
+		settle: () => {
+			resolveCommitted();
+			resolveFinished();
+		},
+		fail: (error) => {
+			rejectCommitted(error);
+			rejectFinished(error);
+		},
+		adopt: (result) => {
+			if (result.committed === void 0) resolveCommitted();
+			else result.committed.then(() => resolveCommitted(), rejectCommitted);
+			if (result.finished === void 0) resolveFinished();
+			else result.finished.then(() => resolveFinished(), rejectFinished);
+		}
+	};
+};
+/**
+* The shared half of every store: an immutable snapshot over a fixed key set,
+* exact per-key change detection, and notification only to the listeners
+* whose subscribed keys actually changed.
+*/
+const createStoreCore = (keys, initial) => {
+	const listeners = /* @__PURE__ */ new Set();
+	const picks = /* @__PURE__ */ new Map();
+	let snapshot = initial;
+	return {
+		snapshot: () => snapshot,
+		applyNext: (next) => {
+			const changed = [];
+			const merged = {};
+			for (const key of keys) if (sameValue(snapshot[key], next[key])) merged[key] = snapshot[key];
+			else {
+				merged[key] = next[key];
+				changed.push(key);
+			}
+			if (changed.length === 0) return;
+			snapshot = merged;
+			for (const [sig, pick] of picks) if (changed.some((key) => pick.keys.includes(key))) picks.delete(sig);
+			for (const listener of listeners) {
+				const subscribed = listener.keys;
+				if (subscribed === null || changed.some((key) => subscribed.has(key))) listener.notify();
+			}
+		},
+		subscribe: (subscribedKeys, notify) => {
+			const listener = {
+				keys: subscribedKeys === null ? null : new Set(subscribedKeys),
+				notify
+			};
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		getSnapshot: (sig, pickKeys) => {
+			if (pickKeys === null) return snapshot;
+			let pick = picks.get(sig);
+			if (pick === void 0) {
+				const value = {};
+				for (const key of pickKeys) value[key] = snapshot[key];
+				pick = {
+					keys: pickKeys,
+					value
+				};
+				picks.set(sig, pick);
+			}
+			return pick.value;
+		},
+		clear: () => {
+			listeners.clear();
+			picks.clear();
+		}
+	};
+};
+/**
+* The unknown-field guard every store shares: the typed API already prevents
+* this, so reaching it means an untyped caller — fail loudly, not silently.
+*/
+const resolvePatch = (patch, current, keys, label) => {
+	const resolved = typeof patch === "function" ? patch({ ...current }) : patch;
+	for (const key of Object.keys(resolved)) if (!keys.includes(key)) throw new TypeError(`"${label}" has no field "${key}"`);
+	return resolved;
+};
+//#endregion
+export { createHandle, createStoreCore, resolvePatch };

package/dist/store/local-store.d.mts

@@ -0,0 +1,9 @@
+import { StateValues } from "../schema/object.mjs";
+import { LocalState } from "../local-state.mjs";
+import { Store } from "./core.mjs";
+//#region src/store/local-store.d.ts
+declare const localStoreOf: (def: LocalState) => Store;
+/** SSR and hydration see the defaults — the server has no localStorage. */
+declare const localInitialSnapshot: (def: LocalState) => StateValues;
+//#endregion
+export { localInitialSnapshot, localStoreOf };

package/dist/store/local-store.mjs

@@ -0,0 +1,80 @@
+import { localCodecOf } from "../local-state.mjs";
+import { createHandle, createStoreCore, resolvePatch } from "./core.mjs";
+import { getOrCreateStore } from "./registry.mjs";
+//#region src/store/local-store.ts
+const storageKeyOf = (def) => `k8ordo-state:${def.key}`;
+const createLocalStore = (def) => {
+	const codec = localCodecOf(def);
+	const storageKey = storageKeyOf(def);
+	const read = () => {
+		const text = localStorage.getItem(storageKey);
+		if (text === null) return codec.parse(void 0);
+		try {
+			return codec.parse(JSON.parse(text));
+		} catch {
+			return codec.parse(void 0);
+		}
+	};
+	const core = createStoreCore(codec.keys, read());
+	let pending = null;
+	let handle = null;
+	const onStorage = (event) => {
+		if (event.storageArea !== localStorage) return;
+		if (event.key !== storageKey && event.key !== null) return;
+		const fresh = read();
+		core.applyNext(pending === null ? fresh : {
+			...fresh,
+			...pending
+		});
+	};
+	window.addEventListener("storage", onStorage);
+	const flush = () => {
+		const patch = pending;
+		const current = handle;
+		pending = null;
+		handle = null;
+		const target = codec.salvage({
+			...read(),
+			...patch
+		});
+		const values = {};
+		for (const key of codec.keys) values[key] = target[key];
+		try {
+			localStorage.setItem(storageKey, JSON.stringify(values));
+			core.applyNext(target);
+			current.settle();
+		} catch (error) {
+			current.fail(error);
+		}
+	};
+	const update = (patch) => {
+		const resolved = resolvePatch(patch, core.snapshot(), codec.keys, def.key);
+		if (pending === null) {
+			pending = {};
+			handle = createHandle();
+			queueMicrotask(flush);
+		}
+		Object.assign(pending, resolved);
+		const echoed = codec.salvage({
+			...core.snapshot(),
+			...pending
+		});
+		for (const key of Object.keys(pending)) pending[key] = echoed[key];
+		core.applyNext(echoed);
+		return handle.external;
+	};
+	return {
+		subscribe: core.subscribe,
+		getSnapshot: core.getSnapshot,
+		update,
+		dispose: () => {
+			window.removeEventListener("storage", onStorage);
+			core.clear();
+		}
+	};
+};
+const localStoreOf = (def) => getOrCreateStore("local", def.key, () => createLocalStore(def));
+/** SSR and hydration see the defaults — the server has no localStorage. */
+const localInitialSnapshot = (def) => ({ ...localCodecOf(def).defaults });
+//#endregion
+export { localInitialSnapshot, localStoreOf };

package/dist/store/memory-store.d.mts

@@ -0,0 +1,9 @@
+import { StateValues } from "../schema/object.mjs";
+import { MemoryState } from "../memory-state.mjs";
+import { Store } from "./core.mjs";
+//#region src/store/memory-store.d.ts
+declare const memoryStoreOf: (def: MemoryState) => Store;
+/** SSR renders the initial values — static, so no cross-request concern. */
+declare const memoryInitialSnapshot: (def: MemoryState) => StateValues;
+//#endregion
+export { memoryInitialSnapshot, memoryStoreOf };

package/dist/store/memory-store.mjs

@@ -0,0 +1,28 @@
+import { createHandle, createStoreCore, resolvePatch } from "./core.mjs";
+import { getOrCreateStore } from "./registry.mjs";
+//#region src/store/memory-store.ts
+const createMemoryStore = (def) => {
+	const keys = Object.keys(def.initial);
+	const core = createStoreCore(keys, { ...def.initial });
+	const update = (patch) => {
+		const resolved = resolvePatch(patch, core.snapshot(), keys, def.key);
+		core.applyNext({
+			...core.snapshot(),
+			...resolved
+		});
+		const handle = createHandle();
+		handle.settle();
+		return handle.external;
+	};
+	return {
+		subscribe: core.subscribe,
+		getSnapshot: core.getSnapshot,
+		update,
+		dispose: core.clear
+	};
+};
+const memoryStoreOf = (def) => getOrCreateStore("memory", def.key, () => createMemoryStore(def));
+/** SSR renders the initial values — static, so no cross-request concern. */
+const memoryInitialSnapshot = (def) => ({ ...def.initial });
+//#endregion
+export { memoryInitialSnapshot, memoryStoreOf };