@plitzi/nexus 0.31.1 → 0.32.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @plitzi/nexus
 
+## 0.32.0
+
+### Minor Changes
+
+- v0.32.0
+
+## 0.31.2
+
+### Patch Changes
+
+- v0.31.2
+
 ## 0.31.1
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,10 @@
+<p align="center">
+  <img src="./logo.svg" alt="@plitzi/nexus" width="640" />
+</p>
+
 # @plitzi/nexus
 
-A lightweight, type-safe React store built on `useSyncExternalStore`. You subscribe to **dot-notation paths** and re-render only when that exact value changes — no selectors, no reducers, no action types. On top of that core it ships scoped stores, time-travel, derived values, an entity adapter, and a middleware pipeline (logger / persist / history).
+A lightweight, type-safe React store built on `useSyncExternalStore`. You subscribe to **dot-notation paths** and re-render only when that exact value changes — no selectors, no reducers, no action types. On top of that core it ships scoped stores, time-travel, derived values, an entity adapter, and a middleware pipeline (logger / persist / history). Fully compatible with SSR, React Server Components, and Next.js App Router.
 
 ```bash
 npm install @plitzi/nexus   # peer deps: react@^18 || ^19, react-dom@^18 || ^19
@@ -33,6 +37,10 @@ function Counter() {
 | `createDerived` / `useDerived` | A memoized value computed from store paths (reselect-style). |
 | `createEntityAdapter` | CRUD updaters + selectors for a normalized `Record<id, T>` map. |
 | `loggerMiddleware` / `persistMiddleware` / `historyMiddleware` / `reduxDevToolsMiddleware` | Middlewares: log, persist to storage, record time-travel, connect to Redux DevTools. |
+| `setCodegenEnabled` | Force on/off the `new Function` codegen path (auto-detects CSP/SSR). |
+| `createServerSnapshot` | Mark server-fetched data for RSC → Client handoff. |
+| `isServerSnapshot` | Check if a value has the SSR marker flag. |
+| `bindServerAction` | Optimistic updates + revalidation for Next.js Server Actions. |
 | `getStoreHistory` / `useStoreHistory` | Undo / redo / jump-to-snapshot action log (enabled by `historyMiddleware`). |
 
 ## Architecture
@@ -528,6 +536,194 @@ setCodegenEnabled(false);
 
 Call `setCodegenEnabled(undefined)` to restore auto-detection.
 
+## Server Components & SSR
+
+Nexus supports React Server Components (App Router) and server-side rendering (Pages Router) with no additional setup.
+
+### Auto-detected SSR safety
+
+When a store is created on the server (`typeof window === 'undefined'`), Nexus automatically:
+
+- **Disables codegen** — `new Function` is never called, so a strict Content-Security-Policy won't break SSR. Falls back to the recursive writer with identical behaviour.
+- **Disables localStorage** — `persistMiddleware` falls back to a no-op storage so `getItem`/`setItem` never throw.
+- **Defers hydration** — `StoreProvider` runs `persistMiddleware` hydration in a `useEffect` after React hydration, preventing hydration mismatches.
+
+You don't need to configure anything for SSR to work.
+
+### Server Components → Client data handoff
+
+Wrap server-fetched data with `createServerSnapshot` to mark it as coming from the server:
+
+```tsx
+// app/page.tsx — Server Component (App Router)
+import { StoreProvider } from '@plitzi/nexus';
+import { createServerSnapshot } from '@plitzi/nexus/rsc';
+
+export default async function Page() {
+  const posts = await fetch('https://api.example.com/posts').then(r => r.json());
+
+  return (
+    <StoreProvider value={createServerSnapshot({ posts })}>
+      <ClientContent />
+    </StoreProvider>
+  );
+}
+```
+
+```tsx
+// app/ClientContent.tsx — Client Component
+'use client';
+const { useStore } = createStoreHook<{ posts: Post[] }>();
+
+function ClientContent() {
+  const [posts] = useStore('posts');
+  // posts is available without a loading state — it was already fetched on the server
+}
+```
+
+The SSR flag is a non-enumerable Symbol — invisible in spread/JSON. Using `createServerSnapshot` is optional; plain objects work too.
+
+### `rsc` subpath exports
+
+| Import | What it's for |
+|---|---|
+| `createServerSnapshot` | Mark data as server-fetched (type-level marker) |
+| `isServerSnapshot` | Check if a value has the SSR flag |
+| `stripServerFlag` | Remove the SSR flag from a value |
+
+Import from `@plitzi/nexus/rsc` or from the main entry.
+
+### App Router — full pattern
+
+```tsx
+// app/providers.tsx
+'use client';
+import { StoreProvider, createServerSnapshot } from '@plitzi/nexus';
+import type { ReactNode } from 'react';
+
+type AppState = {
+  user: { name: string; email: string } | null;
+  theme: 'light' | 'dark';
+  posts: Array<{ id: string; title: string }>;
+};
+
+export function AppProviders({
+  children,
+  initialState
+}: {
+  children: ReactNode;
+  initialState: AppState;
+}) {
+  return (
+    <StoreProvider value={createServerSnapshot(initialState)}>
+      {children}
+    </StoreProvider>
+  );
+}
+
+// app/layout.tsx — Server Component
+import { AppProviders } from './providers';
+
+export default async function RootLayout({ children }: { children: React.ReactNode }) {
+  const user = await getServerSession();
+  return (
+    <html>
+      <body>
+        <AppProviders initialState={{ user, theme: 'light', posts: [] }}>
+          {children}
+        </AppProviders>
+      </body>
+    </html>
+  );
+}
+
+// app/dashboard/page.tsx — Server Component
+export default async function DashboardPage() {
+  const posts = await db.posts.findMany();
+  return <DashboardClient posts={posts} />;
+}
+
+// app/dashboard/DashboardClient.tsx — Client Component
+'use client';
+import { useStoreSync, createStoreHook } from '@plitzi/nexus';
+
+type State = { posts: Array<{ id: string; title: string }> };
+const { useStore } = createStoreHook<State>();
+
+export function DashboardClient({ posts }: { posts: State['posts'] }) {
+  // Sync server data on mount — avoids overwriting user edits on re-renders
+  useStoreSync('posts', posts, { mode: 'mount' });
+  const [localPosts] = useStore('posts');
+
+  return (
+    <div>
+      {localPosts.map(post => <div key={post.id}>{post.title}</div>)}
+    </div>
+  );
+}
+```
+
+### Pages Router — full pattern
+
+```tsx
+// pages/dashboard.tsx
+import { createStoreHook, StoreProvider } from '@plitzi/nexus';
+import type { InferGetServerSidePropsType } from 'next';
+
+type State = { count: number; user: { name: string } };
+
+export const getServerSideProps = async () => {
+  const user = await api.getUser();
+  return { props: { user } };
+};
+
+export default function DashboardPage({
+  user
+}: InferGetServerSidePropsType<typeof getServerSideProps>) {
+  return (
+    <StoreProvider value={{ user, count: 0 }}>
+      <Dashboard />
+    </StoreProvider>
+  );
+}
+
+// components/Dashboard.tsx
+'use client';
+const { useStore } = createStoreHook<State>();
+
+function Dashboard() {
+  const [user] = useStore('user');
+  const [count, setCount] = useStore('count');
+  return <div>...</div>;
+}
+```
+
+### Server Actions (`@plitzi/nexus/next`)
+
+The `@plitzi/nexus/next` subpath exports a `bindServerAction` helper for optimistic updates
+with automatic revalidation:
+
+```tsx
+'use client';
+import { useStore } from '@plitzi/nexus';
+import { bindServerAction } from '@plitzi/nexus/next';
+
+function Likes({ store, updateLikes }: { store: StoreApi<State>; updateLikes: ServerAction }) {
+  const [likes, setLikes] = useStore('likes');
+  const syncLikes = bindServerAction(store, 'likes', updateLikes, { revalidatePath: '/dashboard' });
+
+  return <button onClick={() => syncLikes(n => n + 1)}>{likes}</button>;
+}
+```
+
+| Import | What it's for |
+|---|---|
+| `bindServerAction` | Optimistic update + rollback + revalidation for Next.js Server Actions |
+| `ServerActionResult` | Return type of `bindServerAction` |
+
+This module dynamically imports from `next/cache` — it only works within Next.js App Router.
+It is **not** a peer dependency, just a compatibility layer.
+
 ## Performance
 
 Notification is `O(depth)` — a few `Map` lookups for the changed path's prefixes — **regardless of how many subscribers exist**, so a million watchers cost the same as one for an unrelated change. The *write* copies the containers on the changed path (immutable structural sharing, the same cost Redux / Zustand / Jotai pay), so model state as a **tree / normalized map** to keep each write touching a small path. Single-segment writes mutate the live working copy in place (O(1)); snapshots from `getState()` are always distinct clones, so they stay immutable for React.

package/dist/StoreProvider.mjs

@@ -1,51 +1,57 @@
 import { StoreContext as e, StoreRegistryContext as t } from "./StoreContext.mjs";
 import n from "./createStore/hooks/useStoreSync.mjs";
 import r from "./createStore/index.mjs";
-import { createContext as i, useContext as a, useEffect as o, useMemo as s, useRef as c } from "react";
-import { jsx as l } from "react/jsx-runtime";
+import { isServerSnapshot as i, stripServerFlag as a } from "./rsc/index.mjs";
+import { createContext as o, useContext as s, useEffect as c, useMemo as l, useRef as u } from "react";
+import { jsx as d } from "react/jsx-runtime";
 //#region src/StoreProvider.tsx
-var u = i(void 0), d = (e) => e.cascade === !0, f = ({ store: i, id: f, path: p, value: m, inherit: h, autoSync: g = !0, middlewares: _, children: v }) => {
-	let y = a(e), b = a(u), x = a(t), S = c(void 0), C = h === "live", w = s(() => {
-		let e = h === "snapshot" && y ? y.getState() : {};
-		return typeof m == "function" ? m(e) : {
+var f = o(void 0), p = (e) => e.cascade === !0, m = ({ store: o, id: m, path: h, value: g, inherit: _, autoSync: v = !0, middlewares: y, children: b }) => {
+	let x = s(e), S = s(f), C = s(t), w = u(void 0), T = _ === "live", E = l(() => {
+		let e = _ === "snapshot" && x ? x.getState() : {}, t = typeof g == "function" ? g(e) : {
 			...e,
-			...m
+			...g
 		};
+		return i(t) ? a(t) : t;
 	}, [
-		h,
-		y,
-		m
-	]), T = _ ?? [], E = b ? [...b, ...T] : T, D = s(() => [...b ?? [], ...T.filter(d)], [b, _]);
-	S.current ||= i ?? r(() => w, {
-		id: f,
-		parent: C ? y : void 0,
-		middlewares: E.length > 0 ? E : void 0
+		_,
+		x,
+		g
+	]), D = y ?? [], O = S ? [...S, ...D] : D, k = l(() => [...S ?? [], ...D.filter(p)], [S, y]);
+	w.current ||= o ?? r(() => E, {
+		id: m,
+		parent: T ? x : void 0,
+		middlewares: O.length > 0 ? O : void 0,
+		deferHydrate: !0
 	});
-	let O = s(() => f ? {
-		id: f,
-		store: S.current,
-		parent: x
-	} : x, [f, x]);
-	c(!1), o(() => {}, [f, x]), o(() => (C && !i && S.current?.reconnect?.(), () => {
-		C && !i && S.current?.destroy?.();
-	}), [C, i]);
-	let k = !!m && g;
-	return n(p, p ? m : w, {
-		enabled: k && !!p,
-		store: S.current
-	}), n(void 0, w, {
-		enabled: k && !p,
-		store: S.current
-	}), /* @__PURE__ */ l(u, {
-		value: D.length > 0 ? D : void 0,
-		children: /* @__PURE__ */ l(t, {
-			value: O,
-			children: /* @__PURE__ */ l(e, {
-				value: S.current,
-				children: v
+	let A = l(() => m ? {
+		id: m,
+		store: w.current,
+		parent: C
+	} : C, [m, C]);
+	u(!1), c(() => {}, [m, C]), c(() => (T && !o && w.current?.reconnect?.(), () => {
+		T && !o && w.current?.destroy?.();
+	}), [T, o]);
+	let j = u(!1);
+	c(() => {
+		!j.current && w.current?.hydrate && (w.current.hydrate(), j.current = !0);
+	}, []);
+	let M = !!g && v;
+	return n(h, h ? g : E, {
+		enabled: M && !!h,
+		store: w.current
+	}), n(void 0, E, {
+		enabled: M && !h,
+		store: w.current
+	}), /* @__PURE__ */ d(f, {
+		value: k.length > 0 ? k : void 0,
+		children: /* @__PURE__ */ d(t, {
+			value: A,
+			children: /* @__PURE__ */ d(e, {
+				value: w.current,
+				children: b
 			})
 		})
 	});
 };
 //#endregion
-export { f as default };
+export { m as default };

package/dist/async/createAsync.mjs

@@ -11,7 +11,14 @@ function t(t, n, r, i = {}) {
 	}, d = l.get, f = (...e) => {
 		a = "pending", o = void 0;
 		let i = Promise.resolve().then(() => r(...e));
-		return s = i, c = i.then(() => void 0, () => void 0), u(), i.then((e) => (i === s && (s = void 0, c = void 0, a = "success", t.setState(n, e), u()), e), (e) => {
+		return s = i, c = i.then(() => void 0, () => void 0), u(), i.then((e) => {
+			if (i === s) {
+				s = void 0, c = void 0, a = "success";
+				let r = t.getPath(n);
+				t.setState(n, e), Object.is(r, e) && u();
+			}
+			return e;
+		}, (e) => {
 			throw i === s && (s = void 0, c = void 0, a = "error", o = e, u()), e;
 		});
 	}, p = t.subscribePath(n, u);

package/dist/createStore/createStore.d.ts

@@ -1,70 +1,37 @@
-import { GetState, GetterTuple, GetValueFn, GetValueFromBaseFn, GetValueFromBaseWithDefaultFn, MultiPathReturn, PathOf, PathOrFn, PathOrFnSetters, PathOrFnValue, PathOrFnValues, PathSetters, PathSetter, PathValue, PathValues, SetFromBaseFn, SetState, SetStateFn, StoreApi, StoreMiddleware, UseStoreGetterOptions, UseStoreMultiOptions, UseStoreOptions, UseStoreSetterOptions, UseStoreSyncMultiOptions, UseStoreSyncOptions } from '../types';
-declare function createStore<TState extends object>(initializer: Partial<TState> | ((set: SetState<TState>, get: GetState<TState>) => Partial<TState>), storeOptions?: {
+import { GetState, GetterTuple, GetValueFn, GetValueFromBaseFn, MultiPathReturn, PathOf, PathOrFn, PathOrFnSetters, PathOrFnValues, PathSetters, PathSetter, PathValue, PathValues, SetFromBaseFn, SetState, SetStateFn, StoreApi, StoreMiddleware, UseStoreGetterOptions, UseStoreMultiOptions, UseStoreOptions, UseStoreSetterOptions, UseStoreSyncMultiOptions, UseStoreSyncOptions } from '../types';
+export type CreateStoreOptions<TState extends object> = {
     id?: string;
     parent?: StoreApi<TState>;
     middlewares?: StoreMiddleware<TState>[];
-}): StoreApi<TState>;
+    /** When true, hydrate handlers are collected but NOT run during creation.
+     *  Call `store.hydrate()` manually (StoreProvider does this in a useEffect).
+     *  Defaults to false (backward-compatible: standalone usage hydrates synchronously). */
+    deferHydrate?: boolean;
+};
+declare function createStore<TState extends object>(initializer: Partial<TState> | ((set: SetState<TState>, get: GetState<TState>) => Partial<TState>), storeOptions?: CreateStoreOptions<TState>): StoreApi<TState>;
 export declare const createStoreHook: <TState extends object>() => {
     useStore: {
         (options?: UseStoreOptions<TState, TState>): [TState, StoreApi<TState>["setState"]];
-        <P extends PathOf<TState>>(path: P, options: Omit<UseStoreOptions<PathValue<TState, P>, TState>, "defaultValue"> & {
-            defaultValue: undefined;
-            transformer?: never;
-        }): [PathValue<TState, P> | undefined, (value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)) => void];
         <P extends PathOf<TState>>(path: P, options?: UseStoreOptions<PathValue<TState, P>, TState> & {
-            defaultValue?: never;
             transformer?: never;
         }): [PathValue<TState, P>, (value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)) => void];
-        <P extends PathOf<TState>, D>(path: P, options: UseStoreOptions<PathValue<TState, P>, TState> & {
-            defaultValue: D;
-            transformer?: never;
-        }): [NonNullable<PathValue<TState, P>> | D, (value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)) => void];
         <P extends PathOf<TState>, TResult>(path: P, options: UseStoreOptions<PathValue<TState, P>, TState> & {
             transformer: (value: PathValue<TState, P>) => TResult;
         }): [TResult, (value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)) => void];
-        <P extends PathOf<TState>>(pathFn: (state: TState) => P, options: Omit<UseStoreOptions<PathValue<TState, P>, TState>, "defaultValue"> & {
-            defaultValue: undefined;
-            transformer?: never;
-        }): [PathValue<TState, P> | undefined, PathSetter<TState, P>];
         <P extends PathOf<TState>>(pathFn: (state: TState) => P, options?: UseStoreOptions<PathValue<TState, P>, TState> & {
-            defaultValue?: never;
             transformer?: never;
         }): [PathValue<TState, P>, PathSetter<TState, P>];
-        <P extends PathOf<TState>, D_1>(pathFn: (state: TState) => P, options: UseStoreOptions<PathValue<TState, P>, TState> & {
-            defaultValue: D_1;
-            transformer?: never;
-        }): [NonNullable<PathValue<TState, P>> | D_1, PathSetter<TState, P>];
         <P extends PathOf<TState>, TResult_1>(pathFn: (state: TState) => P, options: UseStoreOptions<PathValue<TState, P>, TState> & {
             transformer: (value: PathValue<TState, P>) => TResult_1;
         }): [TResult_1, PathSetter<TState, P>];
-        <const Paths extends ReadonlyArray<PathOf<TState>>>(paths: Paths, options?: Omit<UseStoreMultiOptions<TState, Paths>, "defaultValue" | "transformer">): MultiPathReturn<TState, Paths>;
-        <const Paths extends ReadonlyArray<PathOf<TState>>>(paths: Paths, options: UseStoreMultiOptions<TState, Paths> & {
-            defaultValue: undefined;
-            transformer?: never;
-        }): MultiPathReturn<TState, Paths, undefined>;
-        <const Paths extends ReadonlyArray<PathOf<TState>>, const TDefaultValue extends readonly (PathValue<TState, Paths[number]> | undefined)[]>(paths: Paths, options: UseStoreMultiOptions<TState, Paths, TDefaultValue> & {
-            defaultValue: TDefaultValue;
-            transformer?: never;
-        }): MultiPathReturn<TState, Paths, TDefaultValue>;
-        <const Paths extends ReadonlyArray<PathOf<TState>>, TDefaultValue_1 extends PathValue<TState, Paths[number]>>(paths: Paths, options: UseStoreMultiOptions<TState, Paths, TDefaultValue_1> & {
-            defaultValue: TDefaultValue_1;
-            transformer?: never;
-        }): MultiPathReturn<TState, Paths, TDefaultValue_1>;
+        <const Paths extends ReadonlyArray<PathOf<TState>>>(paths: Paths, options?: Omit<UseStoreMultiOptions<TState, Paths>, "transformer">): MultiPathReturn<TState, Paths>;
         <const Paths extends ReadonlyArray<PathOf<TState>>, TResult_2>(paths: Paths, options: UseStoreMultiOptions<TState, Paths> & {
             transformer: (values: PathValues<TState, Paths>) => TResult_2;
         }): [TResult_2, ...PathSetters<TState, Paths>];
-        <const Entries extends ReadonlyArray<PathOrFn<TState>>>(paths: Entries, options?: Omit<UseStoreMultiOptions<TState, any>, "defaultValue" | "transformer"> & {
+        <const Entries extends ReadonlyArray<PathOrFn<TState>>>(paths: Entries, options?: Omit<UseStoreMultiOptions<TState, any>, "transformer"> & {
             transformer?: never;
         }): [PathOrFnValues<TState, Entries>, ...PathOrFnSetters<TState, Entries>];
-        <const Entries extends ReadonlyArray<PathOrFn<TState>>>(paths: Entries, options: Omit<UseStoreMultiOptions<TState, any>, "defaultValue" | "transformer"> & {
-            defaultValue: undefined;
-            transformer?: never;
-        }): [{ [I in keyof Entries]: PathOrFnValue<TState, Entries[I]> | undefined; }, ...PathOrFnSetters<TState, Entries>];
-        <const Entries extends ReadonlyArray<PathOrFn<TState>>, const TDefaultValue_2 extends readonly unknown[]>(paths: Entries, options: Omit<UseStoreMultiOptions<TState, any>, "defaultValue" | "transformer"> & {
-            defaultValue: TDefaultValue_2;
-            transformer?: never;
-        }): [{ [I in keyof Entries]: I extends keyof TDefaultValue_2 ? TDefaultValue_2[I] extends undefined ? PathOrFnValue<TState, Entries[I]> | undefined : NonNullable<PathOrFnValue<TState, Entries[I]>> | TDefaultValue_2[I] : PathOrFnValue<TState, Entries[I]>; }, ...PathOrFnSetters<TState, Entries>];
-        <const Entries extends ReadonlyArray<PathOrFn<TState>>, TResult_3>(paths: Entries, options: Omit<UseStoreMultiOptions<TState, any>, "defaultValue" | "transformer"> & {
+        <const Entries extends ReadonlyArray<PathOrFn<TState>>, TResult_3>(paths: Entries, options: Omit<UseStoreMultiOptions<TState, any>, "transformer"> & {
             transformer: (values: PathOrFnValues<TState, Entries>) => TResult_3;
         }): [TResult_3, ...PathOrFnSetters<TState, Entries>];
     };
@@ -77,9 +44,6 @@ export declare const createStoreHook: <TState extends object>() => {
     useStoreGetter: {
         (options?: UseStoreGetterOptions<TState>): GetValueFn<TState>;
         <P extends PathOf<TState>>(basePath: P, options?: UseStoreGetterOptions<TState>): GetValueFromBaseFn<PathValue<TState, P>>;
-        <P extends PathOf<TState>, D_2>(basePath: P, options: UseStoreGetterOptions<TState, D_2> & {
-            defaultValue: D_2;
-        }): GetValueFromBaseWithDefaultFn<PathValue<TState, P>, D_2>;
         <const Entries extends ReadonlyArray<PathOf<TState> | ((state: TState) => unknown)>>(entries: Entries, options?: UseStoreGetterOptions<TState>): GetterTuple<TState, Entries>;
     };
     useStoreSetter: {

package/dist/createStore/createStore.mjs

@@ -12,10 +12,10 @@ import c from "./hooks/useStoreSync.mjs";
 var l = 0;
 function u(a, o) {
 	let s = {}, c, u = new r(), d = new r(), f = new i(), p = new r(), m = () => {
-		p.forEach((e) => e());
-	}, h = [], g = [], _ = o?.parent;
+		p.length !== 0 && p.forEach((e) => e());
+	}, h = [], g = [], _ = [], v = o?.parent;
 	++l;
-	let v = (e, t, n) => {
+	let y = (e, t, n) => {
 		if (g.length === 0) throw e;
 		let r = {
 			error: e,
@@ -23,62 +23,80 @@ function u(a, o) {
 			path: n
 		};
 		for (let e = 0, t = g.length; e < t; e++) g[e](r);
-	}, y = () => s, b = () => c ??= { ...s }, { getState: x, getPath: S, invalidate: C, setActive: w, getMergeCount: T } = e(y, b, _);
-	_ && w(!1);
-	let { setState: E, batch: D } = t({
-		getOwnState: y,
-		getOwnSnapshot: b,
+	}, b = () => s, x = () => c ??= { ...s }, { getState: S, getPath: C, invalidate: w, resetCache: T, getMergeCount: E } = e(b, x, v), D = () => {
+		w(), m();
+	}, O, k, A = !1;
+	v && (T(), k = v.subscribeInvalidate?.(D));
+	let { setState: j, batch: M } = t({
+		getOwnState: b,
+		getOwnSnapshot: x,
 		setOwnState: (e) => {
-			s = e, c = void 0, C();
+			s = e, c = void 0, w();
 		},
 		mutateOwnKey: (e, t) => {
-			s[e] = t, C(), c = void 0;
+			s[e] = t, w(), c = void 0;
 		},
-		parent: _,
+		parent: v,
 		listeners: u,
 		pathListeners: f,
 		changeListeners: d,
 		interceptors: h,
-		reportError: v,
+		reportError: y,
 		invalidateDescendants: m,
 		onDelegateToParent: void 0
-	}), O = () => {
-		C(), m();
-	}, k, A, j = !1, M = () => u.length > 0 || f.size > 0 || d.length > 0, N = () => {
-		k || !_ || (C(), w(!0), k = n(_, u, f, d, x, v, C), A = _.subscribeInvalidate?.(O), d.length > 0 && k.seedBaseline());
-	}, P = () => {
-		k && (k.unsubscribe(), k = void 0, A?.(), A = void 0, w(!1));
+	}), N = () => u.length > 0 || f.size > 0 || d.length > 0, P = () => {
+		O || !v || (w(), T(), O = n(v, u, f, d, S, y, w), d.length > 0 && O.seedBaseline());
 	}, F = () => {
-		_ && (!j && M() ? N() : P());
-	}, I = (e) => (F(), () => {
-		e(), F();
-	}), L = (e) => I(u.add(e)), R = (e, t) => I(f.add(e, t)), z = (e) => {
-		let t = I(d.add(e));
-		return k?.seedBaseline(), t;
+		O && (O.unsubscribe(), O = void 0, T());
+	}, I = () => {
+		v && (!A && N() ? P() : F());
+	}, L = (e) => (I(), () => {
+		e(), I();
+	}), R = (e) => L(u.add(e)), z = (e, t) => L(f.add(e, t)), B = (e) => {
+		let t = L(d.add(e));
+		return O?.seedBaseline(), t;
 	};
-	s = typeof a == "function" ? a(E, x) : a;
-	let B = {
+	s = typeof a == "function" ? a(j, S) : a;
+	let V = {
 		id: o?.id,
-		getState: x,
-		getPath: S,
-		setState: E,
-		batch: D,
-		subscribe: L,
-		subscribePath: R,
-		subscribeChange: z,
+		getState: S,
+		getPath: C,
+		setState: j,
+		withBase: (e) => ({
+			getState: (t) => {
+				let n = C(e);
+				return n === void 0 && t !== void 0 ? t : n;
+			},
+			getPath: (t, n) => {
+				let r = C(`${e}.${t}`);
+				return r === void 0 && n !== void 0 ? n : r;
+			},
+			setState: (t, n) => j(t === void 0 ? e : `${e}.${t}`, n),
+			subscribe: (t) => z(e, t),
+			subscribePath: (t, n) => z(`${e}.${t}`, n)
+		}),
+		batch: M,
+		subscribe: R,
+		subscribePath: z,
+		subscribeChange: B,
 		destroy: () => {
-			j = !0, P(), u.clear(), f.clear(), d.clear(), p.clear();
+			A = !0, F(), u.clear(), f.clear(), d.clear(), p.clear(), k?.();
 		},
 		reconnect: () => {
-			j = !1, F();
+			A = !1, v && (k?.(), k = v.subscribeInvalidate?.(D)), I();
 		},
-		subscribeInvalidate: (e) => p.add(e)
+		subscribeInvalidate: (e) => p.add(e),
+		hydrate: () => {
+			for (let e of _) e();
+		}
 	};
 	if (o?.middlewares) for (let e of o.middlewares) {
-		let t = e(B);
-		t?.beforeChange && h.push(t.beforeChange), t?.onChange && z(t.onChange), t?.onError && g.push(t.onError);
+		let t = e(V);
+		t?.beforeChange && h.push(t.beforeChange), t?.onChange && B(t.onChange), t?.onError && g.push(t.onError);
+		let n = t?.hydrate;
+		n && (o.deferHydrate ? _.push(() => n(V)) : n(V));
 	}
-	return B;
+	return V;
 }
 var d = () => {
 	function e(e, t) {

package/dist/createStore/helpers/PathTrie.d.ts

@@ -3,9 +3,11 @@ import { Listener, Path } from '../../types';
 declare class PathTrie {
     readonly direct: Map<string, Subscribers<Listener>>;
     private readonly descendants;
+    private readonly root;
     size: number;
     add(path: string, listener: Listener): () => void;
     private remove;
+    walkAncestors(segments: readonly string[], cb: (subs: Subscribers<Listener>) => void): void;
     getDescendants(path: string): Set<string> | undefined;
     forEachAffected(changedPath: Path | undefined, cb: (listener: Listener) => void, onError?: (error: unknown) => void): void;
     clear(): void;