@plitzi/nexus 0.31.2 → 0.32.1

package/CHANGELOG.md

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

package/README.md

@@ -22,26 +22,51 @@ function Counter() {
 }
 ```
 
+## The whole imperative API in three verbs
+
+Outside React, a store speaks three words. `get`, `set` and `watch` are typed against your state and cover the common case — the longer `getState` / `getPath` / `subscribePath` names stay for advanced reads (default values) and back-compat.
+
+```ts
+import { createStore } from '@plitzi/nexus';
+
+const store = createStore<State>({ count: 0, user: { name: 'Carlos' } });
+
+store.get('user.name');                 // 'Carlos'  (one path, no full merge)
+store.get();                            // entire state
+store.set('user.name', 'Ada');          // typed dot-path write
+store.set('count', n => n + 1);         // updater form
+const off = store.watch('user.name', name => render(name)); // fires only for this path
+```
+
 ## What each piece is for
 
+### Core — the 90%
+
 | Import | What it's for |
 |---|---|
-| `createStore` | Create a vanilla store (no React needed). |
+| `createStore` | Create a vanilla store (no React needed). Exposes `get` / `set` / `watch`. |
 | `createStoreHook<T>()` | Bind your state type once → fully-typed `useStore*` hooks. |
 | `StoreProvider` | Put a store on React context; optionally scope/sync/record it. |
 | `useStore` | Subscribe + write a path (or paths). Re-renders on change only. |
+
+### Advanced — reach for it when you need it
+
+Also importable from the focused `@plitzi/nexus/advanced` entry point, which keeps root autocomplete on the Core.
+
+| Import | What it's for |
+|---|---|
 | `useStoreSetter` | A stable setter — write without subscribing/re-rendering. |
 | `useStoreGetter` | A stable getter — read current values in callbacks, no re-render. |
 | `useStoreById` | Get a named ancestor store's `StoreApi` by `id` (reachable across disconnected providers). |
 | `useStoreSync` | Mirror an external value (props) **into** the store. |
 | `createDerived` / `useDerived` | A memoized value computed from store paths (reselect-style). |
-| `createEntityAdapter` | CRUD updaters + selectors for a normalized `Record<id, T>` map. |
+| `createEntityAdapter` / `createEntityStore` | CRUD + selectors for a normalized `Record<id, T>` map; the store variant adds O(1) per-item updates. |
+| `createAsync` / `useAsync` / `useAsyncValue` | Race-safe fetch landed on a path; inline UI or Suspense. |
 | `loggerMiddleware` / `persistMiddleware` / `historyMiddleware` / `reduxDevToolsMiddleware` | Middlewares: log, persist to storage, record time-travel, connect to Redux DevTools. |
+| `getStoreHistory` / `useStoreHistory` | Undo / redo / jump-to-snapshot action log (enabled by `historyMiddleware`). |
 | `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. |
+| `createServerSnapshot` / `isServerSnapshot` | Mark server-fetched data for RSC → Client handoff, and check the marker. |
 | `bindServerAction` | Optimistic updates + revalidation for Next.js Server Actions. |
-| `getStoreHistory` / `useStoreHistory` | Undo / redo / jump-to-snapshot action log (enabled by `historyMiddleware`). |
 
 ## Architecture
 

package/dist/advanced/index.d.ts

@@ -0,0 +1,7 @@
+export { default as useStoreById } from '../createStore/hooks/useStoreById';
+export { default as useStoreSetter } from '../createStore/hooks/useStoreSetter';
+export * from '../async';
+export * from '../derived';
+export * from '../entities';
+export * from '../history';
+export * from '../middleware';

package/dist/advanced/index.mjs

@@ -0,0 +1,16 @@
+import e from "../createStore/hooks/useStoreById.mjs";
+import t from "../createStore/hooks/useStoreSetter.mjs";
+import { createAsync as n } from "../async/createAsync.mjs";
+import { useAsync as r } from "../async/hooks/useAsync.mjs";
+import { useAsyncValue as i } from "../async/hooks/useAsyncValue.mjs";
+import { createDerived as a } from "../derived/createDerived.mjs";
+import { useDerived as o } from "../derived/hooks/useDerived.mjs";
+import { createEntityAdapter as s } from "../entities/createEntityAdapter.mjs";
+import { createEntityStore as c } from "../entities/createEntityStore.mjs";
+import { getStoreHistory as l, historyMiddleware as u } from "../middleware/historyMiddleware.mjs";
+import { useStoreHistory as d } from "../history/hooks/useStoreHistory.mjs";
+import { loggerMiddleware as f } from "../middleware/loggerMiddleware.mjs";
+import { persistMiddleware as p } from "../middleware/persistMiddleware.mjs";
+import { reduxDevToolsMiddleware as m } from "../middleware/reduxDevToolsMiddleware.mjs";
+import { cascade as h } from "../middleware/cascade.mjs";
+export { h as cascade, n as createAsync, a as createDerived, s as createEntityAdapter, c as createEntityStore, l as getStoreHistory, u as historyMiddleware, f as loggerMiddleware, p as persistMiddleware, m as reduxDevToolsMiddleware, r as useAsync, i as useAsyncValue, o as useDerived, e as useStoreById, d as useStoreHistory, t as useStoreSetter };

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,4 +1,4 @@
-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';
+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>;
@@ -12,64 +12,26 @@ declare function createStore<TState extends object>(initializer: Partial<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>];
     };
@@ -82,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

@@ -1,18 +1,18 @@
-import { createChainReads as e } from "./helpers/createChainReads.mjs";
-import { createSetState as t } from "./helpers/createSetState.mjs";
-import { forwardParentChanges as n } from "./helpers/forwardParentChanges.mjs";
-import r from "./helpers/Subscribers.mjs";
-import i from "./helpers/PathTrie.mjs";
+import e from "./hooks/useStoreSetter.mjs";
+import t from "./helpers/Subscribers.mjs";
+import { createChainReads as n } from "./helpers/createChainReads.mjs";
+import { createSetState as r } from "./helpers/createSetState.mjs";
+import { forwardParentChanges as i } from "./helpers/forwardParentChanges.mjs";
+import a from "./helpers/PathTrie.mjs";
 import "./helpers/scopeCollisions.mjs";
-import a from "./hooks/useStore.mjs";
-import o from "./hooks/useStoreGetter.mjs";
-import s from "./hooks/useStoreSetter.mjs";
+import o from "./hooks/useStore.mjs";
+import s from "./hooks/useStoreGetter.mjs";
 import c from "./hooks/useStoreSync.mjs";
 //#region src/createStore/createStore.ts
 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());
+function u(e, o) {
+	let s = {}, c, u = new t(), d = new t(), f = new a(), p = new t(), m = () => {
+		p.length !== 0 && p.forEach((e) => e());
 	}, h = [], g = [], _ = [], v = o?.parent;
 	++l;
 	let y = (e, t, n) => {
@@ -23,9 +23,11 @@ function u(a, o) {
 			path: n
 		};
 		for (let e = 0, t = g.length; e < t; e++) g[e](r);
-	}, b = () => s, x = () => c ??= { ...s }, { getState: S, getPath: C, invalidate: w, setActive: T, getMergeCount: E } = e(b, x, v);
-	v && T(!1);
-	let { setState: D, batch: O } = t({
+	}, b = () => s, x = () => c ??= { ...s }, { getState: S, getPath: C, invalidate: w, resetCache: T, getMergeCount: E } = n(b, x, v), D = () => {
+		w(), m();
+	}, O, k, A = !1;
+	v && (T(), k = v.subscribeInvalidate?.(D));
+	let { setState: j, batch: M } = r({
 		getOwnState: b,
 		getOwnSnapshot: x,
 		setOwnState: (e) => {
@@ -42,35 +44,55 @@ function u(a, o) {
 		reportError: y,
 		invalidateDescendants: m,
 		onDelegateToParent: void 0
-	}), k = () => {
-		w(), m();
-	}, A, j, M = !1, N = () => u.length > 0 || f.size > 0 || d.length > 0, P = () => {
-		A || !v || (w(), T(!0), A = n(v, u, f, d, S, y, w), j = v.subscribeInvalidate?.(k), d.length > 0 && A.seedBaseline());
+	}), N = () => u.length > 0 || f.size > 0 || d.length > 0, P = () => {
+		O || !v || (w(), T(), O = i(v, u, f, d, S, y, w), d.length > 0 && O.seedBaseline());
 	}, F = () => {
-		A && (A.unsubscribe(), A = void 0, j?.(), j = void 0, T(!1));
+		O && (O.unsubscribe(), O = void 0, T());
 	}, I = () => {
-		v && (!M && N() ? P() : F());
+		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 A?.seedBaseline(), t;
+		return O?.seedBaseline(), t;
 	};
-	s = typeof a == "function" ? a(D, S) : a;
+	s = typeof e == "function" ? e(j, S) : e;
 	let V = {
 		id: o?.id,
 		getState: S,
 		getPath: C,
-		setState: D,
-		batch: O,
+		setState: j,
+		get: ((e) => e === void 0 ? S() : C(e)),
+		set: j,
+		watch: ((e, t) => typeof e == "function" ? R(e) : z(e, t)),
+		withBase: (e) => {
+			let t = (t, n) => j(t === void 0 ? e : `${e}.${t}`, n);
+			return {
+				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,
+				subscribe: (t) => z(e, t),
+				subscribePath: (t, n) => z(`${e}.${t}`, n),
+				get: (t) => C(t === void 0 ? e : `${e}.${t}`),
+				set: t,
+				watch: (t, n) => typeof t == "function" ? z(e, t) : z(`${e}.${t}`, n)
+			};
+		},
+		batch: M,
 		subscribe: R,
 		subscribePath: z,
 		subscribeChange: B,
 		destroy: () => {
-			M = !0, F(), u.clear(), f.clear(), d.clear(), p.clear();
+			A = !0, F(), u.clear(), f.clear(), d.clear(), p.clear(), k?.();
 		},
 		reconnect: () => {
-			M = !1, I();
+			A = !1, v && (k?.(), k = v.subscribeInvalidate?.(D)), I();
 		},
 		subscribeInvalidate: (e) => p.add(e),
 		hydrate: () => {
@@ -86,23 +108,23 @@ function u(a, o) {
 	return V;
 }
 var d = () => {
-	function e(e, t) {
-		return a(e, t);
+	function t(e, t) {
+		return o(e, t);
 	}
-	function t(e, t, n) {
+	function n(e, t, n) {
 		c(e, t, n);
 	}
-	function n(e, t) {
-		return o(e, t);
-	}
 	function r(e, t) {
 		return s(e, t);
 	}
+	function i(t, n) {
+		return e(t, n);
+	}
 	return {
-		useStore: e,
-		useStoreSync: t,
-		useStoreGetter: n,
-		useStoreSetter: r
+		useStore: t,
+		useStoreSync: n,
+		useStoreGetter: r,
+		useStoreSetter: i
 	};
 };
 //#endregion

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;

package/dist/createStore/helpers/PathTrie.mjs

@@ -1,42 +1,77 @@
 import e from "../../helpers/parsePath.mjs";
 import t from "./Subscribers.mjs";
 //#region src/createStore/helpers/PathTrie.ts
-var n = (e, t, n) => {
-	let r = "";
-	for (let i = 0; i < t; i++) r = r ? `${r}.${e[i]}` : e[i], n(r);
+var n = class {
+	subscribers = null;
+	children = null;
 }, r = class {
 	direct = /* @__PURE__ */ new Map();
 	descendants = /* @__PURE__ */ new Map();
+	root = new n();
 	size = 0;
 	add(r, i) {
-		let a = this.direct.get(r), o = e(r);
-		return a || (a = new t(), this.direct.set(r, a), this.size++, n(o, o.length - 1, (e) => {
-			let t = this.descendants.get(e);
-			t || (t = /* @__PURE__ */ new Set(), this.descendants.set(e, t)), t.add(r);
-		})), a.add(i), () => this.remove(r, a, i, o);
+		let a = e(r), o = this.direct.get(r);
+		if (!o) {
+			o = new t(), this.direct.set(r, o);
+			let e = this.root;
+			for (let t of a) {
+				e.children ||= /* @__PURE__ */ new Map();
+				let r = e.children.get(t);
+				r || (r = new n(), e.children.set(t, r)), e = r;
+			}
+			e.subscribers = o, this.size++;
+			let i = "";
+			for (let e = 0; e < a.length - 1; e++) {
+				i = i ? `${i}.${a[e]}` : a[e];
+				let t = this.descendants.get(i);
+				t || (t = /* @__PURE__ */ new Set(), this.descendants.set(i, t)), t.add(r);
+			}
+		}
+		return o.add(i), () => this.remove(r, o, i, a);
 	}
-	remove(e, t, r, i) {
-		this.direct.get(e) === t && (t.remove(r), !(t.length > 0) && (this.direct.delete(e), this.size--, n(i, i.length - 1, (t) => {
-			let n = this.descendants.get(t);
-			n && (n.delete(e), n.size === 0 && this.descendants.delete(t));
-		})));
+	remove(e, t, n, r) {
+		if (this.direct.get(e) !== t || (t.remove(n), t.length > 0)) return;
+		this.direct.delete(e), this.size--;
+		let i = this.root;
+		for (let e of r) {
+			if (!i.children) return;
+			let t = i.children.get(e);
+			if (!t) return;
+			i = t;
+		}
+		i.subscribers === t && (i.subscribers = null);
+		let a = "";
+		for (let t = 0; t < r.length - 1; t++) {
+			a = a ? `${a}.${r[t]}` : r[t];
+			let n = this.descendants.get(a);
+			n && (n.delete(e), n.size === 0 && this.descendants.delete(a));
+		}
+	}
+	walkAncestors(e, t) {
+		let n = this.root;
+		for (let r of e) {
+			if (!n.children) return;
+			let e = n.children.get(r);
+			if (!e) return;
+			n = e, n.subscribers && t(n.subscribers);
+		}
 	}
 	getDescendants(e) {
 		return this.descendants.get(e);
 	}
-	forEachAffected(t, r, i) {
-		let a = (e) => {
-			e && e.forEach(r, i);
+	forEachAffected(t, n, r) {
+		let i = (e) => {
+			e && e.forEach(n, r);
 		};
 		if (typeof t != "string") {
-			this.direct.forEach(a);
+			this.direct.forEach(i);
 			return;
 		}
-		let o = e(t);
-		n(o, o.length, (e) => a(this.direct.get(e))), this.descendants.get(t)?.forEach((e) => a(this.direct.get(e)));
+		let a = e(t);
+		this.walkAncestors(a, i), this.descendants.get(t)?.forEach((e) => i(this.direct.get(e)));
 	}
 	clear() {
-		this.direct.clear(), this.descendants.clear(), this.size = 0;
+		this.direct.clear(), this.descendants.clear(), this.root.children = null, this.root.subscribers = null, this.size = 0;
 	}
 };
 //#endregion

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

@@ -4,7 +4,7 @@ export type ChainReads<TState extends object> = {
     getState: GetState<TState>;
     getPath: GetPath<TState>;
     invalidate: () => void;
-    setActive: (active: boolean) => void;
+    resetCache: () => void;
     getMergeCount: () => number;
 };
 export declare function createChainReads<TState extends object>(getOwnState: () => TState, getOwnSnapshot: () => TState, parent: StoreApi<TState> | undefined): ChainReads<TState>;

package/dist/createStore/helpers/createChainReads.mjs

@@ -1,36 +1,35 @@
-import { deepMerge as e, isPlainObject as t } from "./deepMerge.mjs";
-import n from "../../helpers/getByPath.mjs";
+import e from "../../helpers/getByPath.mjs";
+import { deepMerge as t, isPlainObject as n } from "./deepMerge.mjs";
 //#region src/createStore/helpers/createChainReads.ts
 function r(r, i, a) {
 	if (!a) return {
 		getState: i,
-		getPath: (e) => n(r(), e),
+		getPath: (t) => e(r(), t),
 		invalidate: () => {},
-		setActive: () => {},
+		resetCache: () => {},
 		getMergeCount: () => 0
 	};
-	let o = a, s = !0, c = !0, l = !1, u, d = 0, f = /* @__PURE__ */ new Map(), p = () => (d++, e(o.getState(), i())), m = () => s ? ((c || u === void 0) && (u = p(), c = !1), u) : p(), h = (e) => {
-		let i = n(r(), e);
-		if (i === void 0) return o.getPath(e);
-		let a = o.getPath(e);
-		return a === void 0 || !t(i) || !t(a) ? i : n(m(), e);
+	let o = a, s = !0, c = !1, l, u = 0, d = /* @__PURE__ */ new Map(), f = () => (u++, t(o.getState(), i())), p = () => ((s || l === void 0) && (l = f(), s = !1), l), m = (t) => {
+		let i = e(r(), t);
+		if (i === void 0) return o.getPath(t);
+		let a = o.getPath(t);
+		return a === void 0 || !n(i) || !n(a) ? i : e(p(), t);
 	};
 	return {
-		getState: m,
+		getState: p,
 		getPath: (e) => {
-			if (!s) return h(e);
-			if (l) f.clear(), l = !1;
-			else if (f.has(e)) return f.get(e);
-			let t = h(e);
-			return f.set(e, t), t;
+			if (c) d.clear(), c = !1;
+			else if (d.has(e)) return d.get(e);
+			let t = m(e);
+			return d.set(e, t), t;
 		},
 		invalidate: () => {
-			c = !0, l = !0;
+			s = !0, c = !0;
 		},
-		setActive: (e) => {
-			s = e, e || (f.clear(), u = void 0, c = !0, l = !1);
+		resetCache: () => {
+			d.clear(), l = void 0, s = !0, c = !1;
 		},
-		getMergeCount: () => d
+		getMergeCount: () => u
 	};
 }
 //#endregion

package/dist/createStore/helpers/createSetState.mjs

@@ -44,12 +44,14 @@ function u(u) {
 			for (let e = 0, t = n.length; e < t; e++) T.add(n[e]);
 			return;
 		}
-		e.begin();
-		try {
-			let e = s(n, t, n.length);
-			e !== o && b(e, "notify", t);
-		} finally {
-			e.end();
+		if (n.length !== 0) {
+			e.begin();
+			try {
+				let e = s(n, t, n.length);
+				e !== o && b(e, "notify", t);
+			} finally {
+				e.end();
+			}
 		}
 	}, D = (e) => {
 		w++;
@@ -77,19 +79,14 @@ function u(u) {
 			v.end();
 		}
 	}, k = (e, t) => {
-		let n = "";
-		for (let r = 0; r < t.length; r++) {
-			n = n ? `${n}.${t[r]}` : t[r];
-			let i = _.direct.get(n);
-			i && E(i, e);
-		}
-	}, A = (e, n, r, i) => {
-		let a = _.getDescendants(e);
-		if (a) for (let o of a) {
-			let a = _.direct.get(o);
-			if (!a) continue;
-			let s = o.slice(i);
-			t(n, s) !== t(r, s) && E(a, e);
+		_.walkAncestors(t, (t) => E(t, e));
+	}, A = (n, r, i, a) => {
+		let o = _.getDescendants(n);
+		if (o) for (let s of o) {
+			let o = _.direct.get(s);
+			if (!o) continue;
+			let c = e(s).slice(a);
+			t(r, c) !== t(i, c) && E(o, n);
 		}
 	}, j = (e, n, r, o) => {
 		let s = e ? t(r, e) : void 0, c = e ? typeof n == "function" ? n(s) : n : void 0;
@@ -108,15 +105,9 @@ function u(u) {
 			if (e === a) return;
 			l = e;
 		}
-		if (l !== r) {
-			if (p(l), v.length > 0 && O(e, r, l), !o) {
-				x();
-				return;
-			}
-			E(g, e), _.size > 0 && _.direct.forEach((n, i) => {
-				t(r, i) !== t(l, i) && E(n, e);
-			});
-		}
+		l !== r && (p(l), v.length > 0 && O(e, r, l), x(), o && (E(g, e), _.size > 0 && _.direct.forEach((n, i) => {
+			t(r, i) !== t(l, i) && E(n, e);
+		})));
 	};
 	return {
 		setState: (i, o, s = !0) => {
@@ -139,11 +130,11 @@ function u(u) {
 				}
 				if (e === n) return;
 				let r = v.length > 0 ? f() : void 0;
-				if (m(i, n), r !== void 0 && O(i, r, f()), s) {
-					E(g, i);
+				if (m(i, n), r !== void 0 && O(i, r, f()), s && (E(g, i), _.size > 0)) {
 					let t = _.direct.get(i);
-					t && E(t, i), A(i, e, n, i.length + 1);
-				} else x();
+					t && E(t, i), A(i, e, n, 1);
+				}
+				x();
 				return;
 			}
 			let b = e(i), w;
@@ -154,7 +145,7 @@ function u(u) {
 			} else w = r(u, i, b, o, typeof o == "function");
 			if (w === n) return;
 			let T = w;
-			p(T), v.length > 0 && O(i, u, T), s ? (E(g, i), k(i, b), A(i, u, T, 0)) : x();
+			p(T), v.length > 0 && O(i, u, T), s && (E(g, i), _.size > 0 && (k(i, b), A(i, u, T, 0))), x();
 		},
 		batch: D
 	};

package/dist/createStore/hooks/shared.d.ts

@@ -1,10 +1,9 @@
 import { PathOf, PathOrFn, StoreApi, SyncMode } from '../../types';
 import { RefObject } from 'react';
 export declare const defaultMultiEqualityFn: (a: unknown[], b: unknown[]) => boolean;
-export declare function makeSingleSnapshot<TState extends object>(store: StoreApi<TState>, pathOrFn: PathOf<TState> | ((state: TState) => PathOf<TState>) | undefined, defaultValue?: unknown): () => unknown;
+export declare function makeSingleSnapshot<TState extends object>(store: StoreApi<TState>, pathOrFn: PathOf<TState> | ((state: TState) => PathOf<TState>) | undefined): () => unknown;
 export declare function makeMultiSnapshot<TState extends object>(store: StoreApi<TState>, pathsRef: RefObject<ReadonlyArray<PathOrFn<TState>>>, lastRef: RefObject<unknown[] | null>, options?: {
     equalityFn?: (a: unknown[], b: unknown[]) => boolean;
-    defaultValue?: unknown;
 }): () => unknown[];
 export declare function useResolvedStore<TState extends object>(optionStore: StoreApi<TState> | undefined, hookName: string, storeId?: string): StoreApi<TState>;
 export declare function useMultiSubscribe<TState extends object>(store: StoreApi<TState>, pathsRef: RefObject<ReadonlyArray<PathOrFn<TState>>>, pathsKey: string, enabled: boolean, mode: SyncMode): (cb: () => void) => () => void;