sveltinia 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dene-
+
+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/README.md

@@ -0,0 +1,91 @@
+# Sveltinia
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/dene-/sveltinia/main/apps/docs/public/logo.svg" alt="Sveltinia" width="96" height="96">
+</p>
+
+<p align="center">
+  <strong>Sveltinia stores for Svelte and SvelteKit.</strong><br>
+  Typed stores, persistence, plugins, action hooks, mutation subscriptions, request-safe SSR.
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/sveltinia"><img alt="npm" src="https://img.shields.io/npm/v/sveltinia?style=for-the-badge&labelColor=090c09&color=3f693a"></a>
+  <img alt="package managers" src="https://img.shields.io/badge/npm%20%7C%20yarn%20%7C%20pnpm%20%7C%20bun-ready-3f693a?style=for-the-badge&labelColor=090c09">
+  <a href="https://svelte.dev"><img alt="Svelte 5" src="https://img.shields.io/badge/Svelte-5-3f693a?style=for-the-badge&labelColor=090c09"></a>
+  <a href="https://www.typescriptlang.org"><img alt="TypeScript" src="https://img.shields.io/badge/TypeScript-ready-3f693a?style=for-the-badge&labelColor=090c09"></a>
+  <a href="https://dene-.github.io/sveltinia/"><img alt="docs" src="https://img.shields.io/badge/docs-live-3f693a?style=for-the-badge&labelColor=090c09"></a>
+</p>
+
+Sveltinia is a Svelte 5 state management library inspired by Pinia. It provides typed stores for Svelte and SvelteKit, persisted Svelte stores, action hooks, mutation subscriptions, plugins, and request-safe SvelteKit SSR state management.
+
+Use it when you want a Pinia alternative for Svelte, familiar SvelteKit Pinia-style ergonomics, or a small store API without a framework-sized abstraction.
+
+## Install
+
+Install it with whichever package manager your project already uses:
+
+```bash
+npm install sveltinia
+# or: yarn add sveltinia
+# or: pnpm add sveltinia
+# or: bun add sveltinia
+```
+
+## Quick start
+
+```ts
+import { createSveltinia, defineStore } from 'sveltinia'
+
+export const sveltinia = createSveltinia({ debug: import.meta.env.DEV })
+
+export const useCounter = defineStore('counter', {
+  state: () => ({ count: 0 }),
+  getters: { double: (state) => state.count * 2 },
+  actions: { increment() { this.count++ } },
+  persist: true
+})
+```
+
+Install first-party plugins once per root:
+
+```ts
+import { createDebugPlugin, createPersistedState } from 'sveltinia'
+
+sveltinia.use(createDebugPlugin()).use(createPersistedState())
+```
+
+Use the store in application code:
+
+```ts
+const counter = useCounter(sveltinia)
+counter.increment()
+console.log(counter.double)
+```
+
+In a Svelte component, adapt it to a Svelte readable store:
+
+```svelte
+<script lang="ts">
+  import { useStore } from 'sveltinia/svelte'
+  import { fromStore } from 'svelte/store'
+  import { useCounter } from '$lib/stores/counter'
+
+  const counter = fromStore(useStore(useCounter()))
+</script>
+
+<button onclick={() => counter.current.increment()}>{counter.current.count}</button>
+```
+
+## Docs
+
+- [Documentation site](https://dene-.github.io/sveltinia/)
+- [GitHub repository](https://github.com/dene-/sveltinia)
+
+## License
+
+MIT
+
+## Contributor
+
+Built and maintained by [dene-](https://github.com/dene-).

package/dist/adapters/svelte.d.ts

@@ -0,0 +1,6 @@
+import { type Readable } from 'svelte/store';
+import type { Sveltinia, Store } from '../internal/types.js';
+export declare const provideSveltinia: (sveltinia: Sveltinia) => Sveltinia;
+export declare const useSveltinia: () => Sveltinia;
+export declare function toSvelteStore<T extends Store>(store: T): Readable<T>;
+export declare const useStore: <T extends Store>(store: T) => Readable<T>;

package/dist/adapters/svelte.js

@@ -0,0 +1,23 @@
+import { readable } from 'svelte/store';
+import { createContext } from 'svelte';
+import { setActiveSveltinia } from '../core.js';
+const [getSveltiniaContext, setSveltiniaContext] = createContext();
+export const provideSveltinia = (sveltinia) => {
+    setActiveSveltinia(sveltinia);
+    setSveltiniaContext(sveltinia);
+    return sveltinia;
+};
+export const useSveltinia = () => getSveltiniaContext();
+// Module-level cache keyed by store identity. `useStore(sameStore)` returns
+// the same readable across calls, avoiding duplicate subscriptions. Stores
+// are stable per sveltinia, so a single module-level map is safe.
+const storeCache = new WeakMap();
+export function toSvelteStore(store) {
+    const cached = storeCache.get(store);
+    if (cached)
+        return cached;
+    const readableStore = readable(store, (set) => store.$subscribe(() => set(store)));
+    storeCache.set(store, readableStore);
+    return readableStore;
+}
+export const useStore = (store) => toSvelteStore(store);

package/dist/adapters/sveltekit.d.ts

@@ -0,0 +1,6 @@
+import type { Sveltinia, SveltiniaOptions, SveltiniaPlugin, StateTree } from '../internal/types.js';
+export declare function createSveltinia(options?: SveltiniaOptions, plugins?: SveltiniaPlugin[]): {
+    create(serialized?: Record<string, StateTree>): Sveltinia;
+    serialize(sveltinia: Sveltinia): Record<string, StateTree>;
+    hydrate(sveltinia: Sveltinia, state: Record<string, StateTree>): void;
+};

package/dist/adapters/sveltekit.js

@@ -0,0 +1,21 @@
+import { createSveltinia as createRoot } from '../core.js';
+import { clone } from '../internal/reactivity.js';
+import { createPersistedState } from '../plugins/persist.js';
+import { createDebugPlugin } from '../plugins/debug.js';
+export function createSveltinia(options = {}, plugins = [createDebugPlugin(), createPersistedState()]) {
+    return {
+        create(serialized) {
+            const sveltinia = createRoot({ ...options, state: serialized ?? options.state });
+            for (const plugin of plugins)
+                sveltinia.use(plugin);
+            return sveltinia;
+        },
+        serialize(sveltinia) {
+            return clone(sveltinia.state);
+        },
+        hydrate(sveltinia, state) {
+            sveltinia.state = clone(state);
+            sveltinia.forEachStore((store) => store.$patch(state[store.$id] ?? {}));
+        },
+    };
+}

package/dist/core.d.ts

@@ -0,0 +1,8 @@
+import type { ComputedCell, DefineStoreOptions, Sveltinia, SveltiniaOptions, SetupCell, SetupStore, StateTree, Store } from './internal/types.js';
+export declare const setActiveSveltinia: (sveltinia?: Sveltinia) => void;
+export declare const getActiveSveltinia: () => Sveltinia | undefined;
+export declare function createSveltinia(options?: SveltiniaOptions): Sveltinia;
+export declare const state: <T>(value: T) => SetupCell<T>;
+export declare const computed: <T>(fn: () => T) => ComputedCell<T>;
+export declare function defineStore<S extends StateTree>(id: string, options: DefineStoreOptions<S>): (sveltinia?: Sveltinia) => Store<S>;
+export declare function defineStore(id: string, setup: SetupStore, options?: DefineStoreOptions | Record<string, unknown>): (sveltinia?: Sveltinia) => Store;

package/dist/core.js

@@ -0,0 +1,69 @@
+import { createStore } from './internal/store-factory.js';
+import { SVELTINIA_PROVISION_KEY, CELL_KIND } from './internal/constants.js';
+import { clone } from './internal/reactivity.js';
+// Module-level active sveltinia is intentional: Sveltinia's ergonomic API lets stores
+// resolve their root implicitly via `defineStore(id, ...)()` without passing
+// the root every time. Only one sveltinia is active at a time per module instance.
+let activeSveltinia;
+export const setActiveSveltinia = (sveltinia) => {
+    activeSveltinia = sveltinia;
+};
+export const getActiveSveltinia = () => activeSveltinia;
+export function createSveltinia(options = {}) {
+    const sveltinia = {
+        state: clone(options.state ?? {}),
+        _stores: new Map(),
+        _plugins: [],
+        _options: options,
+        use(plugin) {
+            this._plugins.push(plugin);
+            return this;
+        },
+        install(app) {
+            setActiveSveltinia(this);
+            app?.provide(SVELTINIA_PROVISION_KEY, this);
+        },
+        dispose() {
+            this.forEachStore((store) => store.$dispose());
+            this._stores.clear();
+        },
+        registerStore(id, store, state) {
+            this.state[id] = state;
+            this._stores.set(id, store);
+        },
+        unregisterStore(id) {
+            this._stores.delete(id);
+        },
+        getStore(id) {
+            return this._stores.get(id);
+        },
+        option(name) {
+            return this._options[name];
+        },
+        forEachStore(callback) {
+            for (const store of this._stores.values())
+                callback(store);
+        },
+        pluginContext(store, options) {
+            return { sveltinia: this, store, options };
+        },
+    };
+    return sveltinia;
+}
+export const state = (value) => ({
+    __sveltiniaCell: CELL_KIND.STATE,
+    value,
+});
+export const computed = (fn) => ({
+    __sveltiniaCell: CELL_KIND.COMPUTED,
+    get value() {
+        return fn();
+    },
+});
+export function defineStore(id, definition, options) {
+    return (sveltinia = activeSveltinia) => {
+        if (!sveltinia)
+            throw new Error(`No active Sveltinia for store "${id}". Pass a root or call setActiveSveltinia().`);
+        return createStore(id, sveltinia, definition, options);
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './internal/types.js';
+export { createSveltinia, defineStore, setActiveSveltinia, getActiveSveltinia, state, computed } from './core.js';
+export { createPersistedState, browserStorage } from './plugins/persist.js';
+export { createDebugPlugin } from './plugins/debug.js';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './internal/types.js';
+export { createSveltinia, defineStore, setActiveSveltinia, getActiveSveltinia, state, computed } from './core.js';
+export { createPersistedState, browserStorage } from './plugins/persist.js';
+export { createDebugPlugin } from './plugins/debug.js';

package/dist/internal/action.d.ts

@@ -0,0 +1,5 @@
+import { type Clock } from './util.js';
+import type { ActionSubscription, DebuggableStore } from './types.js';
+type ActionFn = (...args: unknown[]) => unknown;
+export declare function instrumentAction(name: string, action: ActionFn, store: DebuggableStore & Record<PropertyKey, unknown>, storeId: string, actionSubscribers: Set<ActionSubscription>, clock: Clock): (...args: unknown[]) => unknown;
+export {};

package/dist/internal/action.js

@@ -0,0 +1,51 @@
+import { DEBUG_KIND } from './constants.js';
+import { noopDebugEmitter } from './util.js';
+export function instrumentAction(name, action, store, storeId, actionSubscribers, clock) {
+    return (...args) => {
+        const afterCallbacks = [];
+        const onErrorCallbacks = [];
+        const start = clock();
+        const actionContext = {
+            name,
+            args,
+            store: store,
+            after: (cb) => afterCallbacks.push(cb),
+            onError: (cb) => onErrorCallbacks.push(cb),
+        };
+        actionSubscribers.forEach((cb) => cb(actionContext));
+        const emitDebug = store._emitDebug ?? noopDebugEmitter;
+        const notifyActionSuccess = (value) => {
+            afterCallbacks.forEach((cb) => cb(value));
+            emitDebug({
+                kind: DEBUG_KIND.ACTION,
+                storeId,
+                name,
+                duration: clock() - start,
+            });
+            return value;
+        };
+        const notifyActionError = (error) => {
+            onErrorCallbacks.forEach((cb) => cb(error));
+            emitDebug({
+                kind: DEBUG_KIND.ACTION,
+                storeId,
+                name,
+                duration: clock() - start,
+                error,
+            });
+        };
+        try {
+            const result = action.apply(store, args);
+            return result instanceof Promise
+                ? result.then(notifyActionSuccess, (error) => {
+                    notifyActionError(error);
+                    throw error;
+                })
+                : notifyActionSuccess(result);
+        }
+        catch (error) {
+            notifyActionError(error);
+            throw error;
+        }
+    };
+}

package/dist/internal/constants.d.ts

@@ -0,0 +1,21 @@
+export declare const SVELTINIA_PROVISION_KEY = "sveltinia";
+export declare const CELL_KIND: {
+    readonly STATE: "state";
+    readonly COMPUTED: "computed";
+};
+export declare const MUTATION_TYPE: {
+    readonly DIRECT: "direct";
+    readonly PATCH_OBJECT: "patch object";
+    readonly PATCH_FUNCTION: "patch function";
+    readonly HYDRATE: "hydrate";
+    readonly RESTORE: "restore";
+};
+export declare const DEBUG_KIND: {
+    readonly MUTATION: "mutation";
+    readonly ACTION: "action";
+    readonly PERSISTENCE: "persistence";
+    readonly LIFECYCLE: "lifecycle";
+};
+export declare const REDACTED = "[redacted]";
+export declare const DEFAULT_PERSIST_VERSION = 1;
+export declare const LEGACY_PERSIST_VERSION = 0;

package/dist/internal/constants.js

@@ -0,0 +1,21 @@
+export const SVELTINIA_PROVISION_KEY = 'sveltinia';
+export const CELL_KIND = {
+    STATE: 'state',
+    COMPUTED: 'computed',
+};
+export const MUTATION_TYPE = {
+    DIRECT: 'direct',
+    PATCH_OBJECT: 'patch object',
+    PATCH_FUNCTION: 'patch function',
+    HYDRATE: 'hydrate',
+    RESTORE: 'restore',
+};
+export const DEBUG_KIND = {
+    MUTATION: 'mutation',
+    ACTION: 'action',
+    PERSISTENCE: 'persistence',
+    LIFECYCLE: 'lifecycle',
+};
+export const REDACTED = '[redacted]';
+export const DEFAULT_PERSIST_VERSION = 1;
+export const LEGACY_PERSIST_VERSION = 0;

package/dist/internal/reactivity.d.ts

@@ -0,0 +1,6 @@
+import type { StateTree } from './types.js';
+export declare const isObject: (value: unknown) => value is Record<PropertyKey, unknown>;
+export declare const isSafeKey: (key: PropertyKey) => boolean;
+export declare const clone: <T>(value: T) => T;
+export declare function merge(target: StateTree, patch: StateTree): StateTree;
+export declare function makeObservable<T extends StateTree>(value: T, notify: (path: string, oldValue: unknown, newValue: unknown) => void, base?: string): T;

package/dist/internal/reactivity.js

@@ -0,0 +1,63 @@
+export const isObject = (value) => value !== null && typeof value === 'object';
+const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+export const isSafeKey = (key) => typeof key !== 'string' || !UNSAFE_KEYS.has(key);
+export const clone = (value) => {
+    if (value === undefined)
+        return value;
+    try {
+        return structuredClone(value);
+    }
+    catch {
+        return JSON.parse(JSON.stringify(value));
+    }
+};
+export function merge(target, patch) {
+    for (const key of Object.keys(patch)) {
+        if (!isSafeKey(key))
+            continue;
+        const source = patch[key];
+        if (isObject(source) &&
+            !Array.isArray(source) &&
+            isObject(target[key]) &&
+            !Array.isArray(target[key]))
+            merge(target[key], source);
+        else
+            target[key] = clone(source);
+    }
+    return target;
+}
+export function makeObservable(value, notify, base = '') {
+    if (!isObject(value))
+        return value;
+    const target = value;
+    for (const key of Object.keys(target)) {
+        if (!isSafeKey(key)) {
+            delete target[key];
+            continue;
+        }
+        target[key] = makeObservable(target[key], notify, base ? `${base}.${key}` : key);
+    }
+    return new Proxy(value, {
+        set(target, prop, next, receiver) {
+            if (!isSafeKey(prop))
+                return false;
+            const path = base ? `${base}.${String(prop)}` : String(prop);
+            const old = Reflect.get(target, prop, receiver);
+            const wrapped = makeObservable(next, notify, path);
+            const ok = Reflect.set(target, prop, wrapped, receiver);
+            if (ok && !Object.is(old, next))
+                notify(path, old, next);
+            return ok;
+        },
+        deleteProperty(target, prop) {
+            if (!isSafeKey(prop))
+                return false;
+            const path = base ? `${base}.${String(prop)}` : String(prop);
+            const old = target[prop];
+            const ok = Reflect.deleteProperty(target, prop);
+            if (ok)
+                notify(path, old, undefined);
+            return ok;
+        },
+    });
+}

package/dist/internal/store-factory.d.ts

@@ -0,0 +1,3 @@
+import { type Clock } from './util.js';
+import type { DefineStoreOptions, Sveltinia, SetupStore, StateTree, Store } from './types.js';
+export declare function createStore<S extends StateTree>(id: string, sveltinia: Sveltinia, definition: DefineStoreOptions<S> | SetupStore, setupOptions?: DefineStoreOptions | Record<string, unknown>, clock?: Clock): Store<S>;

package/dist/internal/store-factory.js

@@ -0,0 +1,186 @@
+import { instrumentAction } from './action.js';
+import { CELL_KIND, DEBUG_KIND, MUTATION_TYPE } from './constants.js';
+import { clone, makeObservable, merge } from './reactivity.js';
+import { defaultClock, noopDebugEmitter } from './util.js';
+const isStateCell = (value) => value?.__sveltiniaCell === CELL_KIND.STATE;
+const isComputedCell = (value) => value?.__sveltiniaCell === CELL_KIND.COMPUTED;
+function defineStateAccessor(store, key, reactiveState) {
+    Object.defineProperty(store, key, {
+        enumerable: true,
+        get: () => reactiveState[key],
+        set: (value) => {
+            reactiveState[key] = value;
+        },
+    });
+}
+function defineGetter(store, name, getter, reactiveState) {
+    Object.defineProperty(store, name, {
+        enumerable: true,
+        get: () => getter.call(store, reactiveState),
+    });
+}
+function createStoreShell(id, sveltinia, initialState, clock) {
+    let pendingBatch;
+    let disposed = false;
+    const subscribers = new Set();
+    const actionSubscribers = new Set();
+    const emitMutation = (mutation) => {
+        for (const callback of subscribers)
+            callback(mutation, reactiveState);
+        sveltinia.state[id] = reactiveState;
+        store._emitDebug({ kind: DEBUG_KIND.MUTATION, storeId: id, mutation });
+    };
+    const notify = (path, oldValue, newValue) => {
+        if (disposed)
+            return;
+        const event = { path, oldValue: clone(oldValue), newValue: clone(newValue) };
+        if (pendingBatch) {
+            pendingBatch.events.push(event);
+            return;
+        }
+        emitMutation({ type: MUTATION_TYPE.DIRECT, storeId: id, events: [event] });
+    };
+    const reactiveState = makeObservable(clone(initialState), notify);
+    const store = { $id: id, _emitDebug: noopDebugEmitter };
+    Object.defineProperty(store, '$state', {
+        get: () => reactiveState,
+        set: (value) => store.$patch(value),
+    });
+    Object.keys(reactiveState).forEach((key) => defineStateAccessor(store, key, reactiveState));
+    store.$patch = (patch) => {
+        const type = typeof patch === 'function' ? MUTATION_TYPE.PATCH_FUNCTION : MUTATION_TYPE.PATCH_OBJECT;
+        pendingBatch = {
+            type,
+            storeId: id,
+            payload: typeof patch === 'function' ? undefined : clone(patch),
+            events: [],
+        };
+        try {
+            if (typeof patch === 'function')
+                patch(reactiveState);
+            else
+                merge(reactiveState, patch);
+        }
+        finally {
+            const mutation = pendingBatch;
+            pendingBatch = undefined;
+            if (mutation)
+                emitMutation(mutation);
+        }
+    };
+    store.$subscribe = (callback) => {
+        subscribers.add(callback);
+        return () => subscribers.delete(callback);
+    };
+    store.$onAction = (callback) => {
+        actionSubscribers.add(callback);
+        return () => actionSubscribers.delete(callback);
+    };
+    store.$dispose = () => {
+        disposed = true;
+        subscribers.clear();
+        actionSubscribers.clear();
+        sveltinia.unregisterStore(id);
+        store._emitDebug({ kind: DEBUG_KIND.LIFECYCLE, storeId: id, name: 'dispose' });
+    };
+    const bindAction = (name, action) => {
+        store[name] = instrumentAction(name, action, store, id, actionSubscribers, clock);
+    };
+    const bindGetter = (name, getter) => {
+        defineGetter(store, name, getter, reactiveState);
+    };
+    const bindStateCell = (name, cell) => {
+        reactiveState[name] = makeObservable(clone(cell.value), notify, name);
+        // Wire the user's cell `.value` to the reactive state so `cell.value++` inside
+        // a setup store reads from and writes to the tracked proxy. This in-place
+        // redirect is intentional: the cell is the user-facing handle, the proxy is
+        // the source of truth.
+        Object.defineProperty(cell, 'value', {
+            configurable: true,
+            get: () => reactiveState[name],
+            set: (value) => {
+                reactiveState[name] = value;
+            },
+        });
+        defineStateAccessor(store, name, reactiveState);
+    };
+    const bindComputedCell = (name, cell) => {
+        Object.defineProperty(store, name, {
+            enumerable: true,
+            get: () => cell.value,
+        });
+    };
+    const bindPlainStateValue = (name, value) => {
+        reactiveState[name] = makeObservable(clone(value), notify, name);
+        defineStateAccessor(store, name, reactiveState);
+    };
+    return {
+        store,
+        reactiveState,
+        bindAction,
+        bindGetter,
+        bindStateCell,
+        bindComputedCell,
+        bindPlainStateValue,
+    };
+}
+const optionsStrategy = {
+    extractInitialState(definition, sveltinia, id) {
+        const opts = definition;
+        return sveltinia.state[id] ?? opts.state();
+    },
+    populate(definition, _id, shell) {
+        const opts = definition;
+        const { store, bindAction, bindGetter } = shell;
+        for (const [name, getter] of Object.entries(opts.getters ?? {}))
+            bindGetter(name, getter);
+        for (const [name, action] of Object.entries(opts.actions ?? {}))
+            bindAction(name, action);
+        store.$reset = () => store.$patch(clone(opts.state()));
+    },
+};
+const setupStrategy = {
+    extractInitialState() {
+        return {};
+    },
+    populate(definition, id, shell) {
+        const setup = definition;
+        const { store, bindAction, bindStateCell, bindComputedCell, bindPlainStateValue } = shell;
+        const setupResult = setup();
+        for (const [name, value] of Object.entries(setupResult)) {
+            if (isStateCell(value))
+                bindStateCell(name, value);
+            else if (isComputedCell(value))
+                bindComputedCell(name, value);
+            else if (typeof value === 'function')
+                bindAction(name, value);
+            else
+                bindPlainStateValue(name, value);
+        }
+        store.$reset = () => {
+            throw new Error(`Setup store "${id}" must expose its own reset action.`);
+        };
+    },
+};
+const strategies = {
+    options: optionsStrategy,
+    setup: setupStrategy,
+};
+function applyPlugins(sveltinia, store, options) {
+    for (const plugin of sveltinia._plugins)
+        Object.assign(store, plugin(sveltinia.pluginContext(store, options)) ?? {});
+}
+export function createStore(id, sveltinia, definition, setupOptions = {}, clock = defaultClock) {
+    const existing = sveltinia.getStore(id);
+    if (existing)
+        return existing;
+    const kind = typeof definition === 'function' ? 'setup' : 'options';
+    const strategy = strategies[kind];
+    const options = kind === 'options' ? definition : setupOptions;
+    const initialState = strategy.extractInitialState(definition, sveltinia, id);
+    const shell = createStoreShell(id, sveltinia, initialState, clock);
+    strategy.populate(definition, id, shell);
+    sveltinia.registerStore(id, shell.store, shell.reactiveState);
+    applyPlugins(sveltinia, shell.store, options);
+    return shell.store;
+}

package/dist/internal/types.d.ts

@@ -0,0 +1,131 @@
+export type StateTree = Record<string, unknown>;
+export type MutationType = 'direct' | 'patch object' | 'patch function' | 'hydrate' | 'restore';
+export interface Mutation {
+    type: MutationType;
+    storeId: string;
+    events?: Array<{
+        path: string;
+        oldValue: unknown;
+        newValue: unknown;
+    }>;
+    payload?: unknown;
+}
+export type Subscription = (mutation: Mutation, state: StateTree) => void;
+export interface ActionContext {
+    name: string;
+    args: unknown[];
+    store: Store;
+    after(cb: (value: unknown) => void): void;
+    onError(cb: (error: unknown) => void): void;
+}
+export type ActionSubscription = (context: ActionContext) => void;
+export interface StorageAdapter {
+    getItem(key: string): string | null | Promise<string | null>;
+    setItem(key: string, value: string): void | Promise<void>;
+    removeItem?(key: string): void | Promise<void>;
+}
+export type Serializer = {
+    serialize(v: unknown): string;
+    deserialize(v: string): unknown;
+};
+export interface PersistOptions {
+    enabled?: boolean;
+    key?: string;
+    storage?: 'localStorage' | 'sessionStorage' | StorageAdapter;
+    paths?: string[];
+    version?: number;
+    migrate?: (state: StateTree, fromVersion: number) => StateTree | Promise<StateTree>;
+    serializer?: Serializer;
+    lazy?: boolean;
+    beforeRestore?: (ctx: {
+        store: Store;
+    }) => void;
+    afterRestore?: (ctx: {
+        store: Store;
+    }) => void;
+}
+export interface DebugEvent {
+    kind: 'mutation' | 'action' | 'persistence' | 'lifecycle';
+    storeId: string;
+    name?: string;
+    mutation?: Mutation;
+    duration?: number;
+    error?: unknown;
+    detail?: unknown;
+}
+export interface DebugOptions {
+    enabled?: boolean;
+    logger?: (event: DebugEvent) => void;
+    redact?: string[];
+}
+export interface SveltiniaOptions {
+    state?: Record<string, StateTree>;
+    debug?: boolean | DebugOptions;
+    persist?: PersistOptions;
+}
+export interface DefineStoreOptions<S extends StateTree = StateTree> {
+    state: () => S;
+    getters?: Record<string, (this: Store<S>, state: S) => unknown>;
+    actions?: Record<string, (...args: unknown[]) => unknown>;
+    persist?: boolean | PersistOptions;
+    debug?: boolean | DebugOptions;
+}
+export interface SetupCell<T> {
+    readonly __sveltiniaCell: 'state';
+    value: T;
+}
+export interface ComputedCell<T> {
+    readonly __sveltiniaCell: 'computed';
+    readonly value: T;
+}
+export type SetupStore = () => Record<string, unknown>;
+export interface ReadableStore<S extends StateTree = StateTree> {
+    $id: string;
+    $state: S;
+    $subscribe(cb: Subscription): () => void;
+    $onAction(cb: ActionSubscription): () => void;
+}
+export interface WritableStore<S extends StateTree = StateTree> {
+    $patch(patch: Partial<S> | ((state: S) => void)): void;
+    $reset(): void;
+}
+export interface PersistableStore {
+    $persist(): Promise<void>;
+    $restore(): Promise<void>;
+    $restored: Promise<void>;
+}
+export interface DisposableStore {
+    $dispose(): void;
+}
+export interface DebuggableStore {
+    _emitDebug?: (event: DebugEvent) => void;
+}
+export interface StoreExtensions {
+}
+export type Store<S extends StateTree = StateTree> = S & ReadableStore<S> & WritableStore<S> & DisposableStore & DebuggableStore & StoreExtensions;
+export type SveltiniaPlugin = (ctx: SveltiniaPluginContext) => void | Record<string, unknown>;
+export interface SveltiniaPluginContext {
+    sveltinia: Sveltinia;
+    store: Store;
+    options: DefineStoreOptions | Record<string, unknown>;
+}
+export interface App {
+    provide(key: string | symbol, value: unknown): void;
+}
+export interface SveltiniaPublic {
+    state: Record<string, StateTree>;
+    use(plugin: SveltiniaPlugin): Sveltinia;
+    install(app?: App): void;
+    dispose(): void;
+    option<K extends keyof SveltiniaOptions>(name: K): SveltiniaOptions[K] | undefined;
+    forEachStore(callback: (store: Store) => void): void;
+}
+export interface Sveltinia extends SveltiniaPublic {
+    _stores: Map<string, Store>;
+    _plugins: SveltiniaPlugin[];
+    _options: SveltiniaOptions;
+    registerStore(id: string, store: Store, state: StateTree): void;
+    unregisterStore(id: string): void;
+    getStore(id: string): Store | undefined;
+    pluginContext(store: Store, options: DefineStoreOptions | Record<string, unknown>): SveltiniaPluginContext;
+}

package/dist/internal/types.js

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

package/dist/internal/util.d.ts

@@ -0,0 +1,8 @@
+import type { DebugEvent } from './types.js';
+export type Clock = () => number;
+export declare const defaultClock: Clock;
+export type DebugEmitter = (event: DebugEvent) => void;
+export declare const noopDebugEmitter: DebugEmitter;
+export declare function flagToObject<T extends {
+    enabled?: boolean;
+}>(value: boolean | T | undefined): T | undefined;

package/dist/internal/util.js

@@ -0,0 +1,9 @@
+export const defaultClock = () => performance.now();
+export const noopDebugEmitter = () => { };
+export function flagToObject(value) {
+    if (value === true)
+        return { enabled: true };
+    if (value === false)
+        return undefined;
+    return value;
+}

package/dist/plugins/debug.d.ts

@@ -0,0 +1,2 @@
+import type { DebugOptions, SveltiniaPluginContext } from '../internal/types.js';
+export declare function createDebugPlugin(defaults?: DebugOptions): ({ sveltinia, store, options }: SveltiniaPluginContext) => void;

package/dist/plugins/debug.js

@@ -0,0 +1,44 @@
+import { DEBUG_KIND, REDACTED } from '../internal/constants.js';
+import { flagToObject } from '../internal/util.js';
+export function createDebugPlugin(defaults = {}) {
+    return ({ sveltinia, store, options }) => {
+        const root = flagToObject(sveltinia.option('debug'));
+        const local = flagToObject(options.debug);
+        const config = {
+            ...defaults,
+            ...root,
+            ...local,
+            enabled: local?.enabled ?? root?.enabled ?? defaults.enabled ?? false,
+        };
+        if (!config.enabled)
+            return;
+        const logger = config.logger ?? consoleDebug;
+        const previousEmitter = store._emitDebug;
+        // Chain with any existing emitter so multiple debug plugins stack instead
+        // of overwriting each other.
+        store._emitDebug = (event) => {
+            previousEmitter?.(event);
+            logger(redact(event, config.redact ?? []));
+        };
+        store._emitDebug({ kind: DEBUG_KIND.LIFECYCLE, storeId: store.$id, name: 'create' });
+    };
+}
+function redact(event, paths) {
+    if (!paths.length || !event.mutation?.events)
+        return event;
+    return {
+        ...event,
+        mutation: {
+            ...event.mutation,
+            events: event.mutation.events.map((e) => paths.some((p) => e.path === p || e.path.startsWith(`${p}.`))
+                ? { ...e, oldValue: REDACTED, newValue: REDACTED }
+                : e),
+        },
+    };
+}
+function consoleDebug(event) {
+    const label = `[sveltinia] ${event.storeId}${event.name ? `/${event.name}` : ''}`;
+    console.groupCollapsed?.(label);
+    console.log(event);
+    console.groupEnd?.();
+}

package/dist/plugins/persist.d.ts

@@ -0,0 +1,7 @@
+import type { PersistOptions, SveltiniaPluginContext, StorageAdapter } from '../internal/types.js';
+declare module '../internal/types.js' {
+    interface StoreExtensions extends PersistableStore {
+    }
+}
+export declare const browserStorage: (kind?: "localStorage" | "sessionStorage") => StorageAdapter | undefined;
+export declare function createPersistedState(defaults?: PersistOptions): ({ sveltinia, store, options }: SveltiniaPluginContext) => void;

package/dist/plugins/persist.js

@@ -0,0 +1,111 @@
+import { clone, isSafeKey, merge } from '../internal/reactivity.js';
+import { DEBUG_KIND, DEFAULT_PERSIST_VERSION, LEGACY_PERSIST_VERSION, } from '../internal/constants.js';
+import { flagToObject } from '../internal/util.js';
+const JSON_SERIALIZER = { serialize: JSON.stringify, deserialize: JSON.parse };
+export const browserStorage = (kind = 'localStorage') => {
+    if (typeof window === 'undefined')
+        return undefined;
+    return window[kind];
+};
+function resolvePersistConfig(value, root) {
+    const local = flagToObject(value);
+    if (!local && !root?.enabled)
+        return undefined;
+    return { ...root, ...local, enabled: local?.enabled ?? root?.enabled ?? true };
+}
+function resolveStorage(config) {
+    if (typeof config.storage === 'object')
+        return config.storage;
+    if (config.storage !== undefined && config.storage !== 'localStorage' && config.storage !== 'sessionStorage')
+        throw new Error(`Unsupported persistence storage "${config.storage}". Use browserStorage('localStorage'), browserStorage('sessionStorage'), or a custom adapter.`);
+    return browserStorage(config.storage ?? 'localStorage');
+}
+function pickPaths(state, paths) {
+    if (!paths?.length)
+        return clone(state);
+    const out = {};
+    for (const path of paths) {
+        const segments = path.split('.');
+        let source = state;
+        let destination = out;
+        for (let i = 0; i < segments.length; i++) {
+            const segment = segments[i];
+            if (!isSafeKey(segment) || !Object.hasOwn(source, segment))
+                break;
+            if (i === segments.length - 1) {
+                destination[segment] = clone(source[segment]);
+            }
+            else {
+                destination[segment] ||= {};
+                destination = destination[segment];
+                source = source[segment];
+            }
+        }
+    }
+    return out;
+}
+function installPersistence(store, config) {
+    const storage = resolveStorage(config);
+    if (!storage)
+        return;
+    const key = config.key ?? `sveltinia:${store.$id}`;
+    const serializer = config.serializer ?? JSON_SERIALIZER;
+    let restoring = false;
+    store.$restore = async () => {
+        config.beforeRestore?.({ store });
+        const value = await storage.getItem(key);
+        if (value) {
+            const envelope = serializer.deserialize(value);
+            let incoming = envelope.state ?? envelope;
+            if (config.version !== undefined && envelope.version !== config.version && config.migrate)
+                incoming = await config.migrate(incoming, envelope.version ?? LEGACY_PERSIST_VERSION);
+            restoring = true;
+            try {
+                store.$patch((state) => merge(state, incoming));
+            }
+            finally {
+                restoring = false;
+            }
+            store._emitDebug?.({
+                kind: DEBUG_KIND.PERSISTENCE,
+                storeId: store.$id,
+                name: 'restore',
+                detail: key,
+            });
+        }
+        config.afterRestore?.({ store });
+    };
+    store.$persist = async () => {
+        const state = pickPaths(store.$state, config.paths);
+        await storage.setItem(key, serializer.serialize({ version: config.version ?? DEFAULT_PERSIST_VERSION, state }));
+        store._emitDebug?.({
+            kind: DEBUG_KIND.PERSISTENCE,
+            storeId: store.$id,
+            name: 'write',
+            detail: key,
+        });
+    };
+    store.$subscribe(() => {
+        if (!restoring)
+            void store.$persist();
+    });
+    if (config.lazy === false) {
+        const restoredPromise = store.$restore();
+        store.$restored = restoredPromise;
+        restoredPromise.catch((error) => {
+            console.error(`[sveltinia] persistence restore failed for "${store.$id}"`, error);
+        });
+    }
+    else {
+        store.$restored = Promise.resolve();
+    }
+}
+export function createPersistedState(defaults = {}) {
+    return ({ sveltinia, store, options }) => {
+        const rootConfig = sveltinia.option('persist');
+        const config = resolvePersistConfig(options.persist, rootConfig ? { ...defaults, ...rootConfig } : defaults);
+        if (!config?.enabled)
+            return;
+        installPersistence(store, config);
+    };
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "sveltinia",
+  "version": "0.1.0",
+  "description": "Typed stores for Svelte and SvelteKit",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "homepage": "https://dene-.github.io/sveltinia/",
+  "repository": {"type":"git","url":"git+https://github.com/dene-/sveltinia.git","directory":"packages/sveltinia"},
+  "bugs": {"url":"https://github.com/dene-/sveltinia/issues"},
+  "keywords": ["svelte", "svelte5", "sveltekit", "svelte-pinia", "sveltekit-pinia", "pinia", "pinia-alternative", "state-management", "svelte-state-management", "svelte-stores", "persisted-stores", "persisted-svelte-stores", "ssr", "sveltekit-ssr"],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {"types":"./dist/index.d.ts","default":"./dist/index.js"},
+    "./svelte": {"types":"./dist/adapters/svelte.d.ts","default":"./dist/adapters/svelte.js"},
+    "./sveltekit": {"types":"./dist/adapters/sveltekit.d.ts","default":"./dist/adapters/sveltekit.js"},
+    "./persist": {"types":"./dist/plugins/persist.d.ts","default":"./dist/plugins/persist.js"},
+    "./debug": {"types":"./dist/plugins/debug.d.ts","default":"./dist/plugins/debug.js"}
+  },
+  "files": ["dist", "README.md", "LICENSE"],
+  "publishConfig": {"access":"public"},
+  "scripts": {"build":"node ../../scripts/clean-dir.mjs dist && tsc -p tsconfig.json"},
+  "peerDependencies": {"svelte":">=5.40.0 <6"}
+}