@plitzi/nexus 0.32.1 → 0.32.3

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # @plitzi/nexus
 
+## 0.32.3
+
+### Patch Changes
+
+- v0.32.3
+
+## 0.32.2
+
+### Patch Changes
+
+- v0.32.2
+
+## Unreleased
+
+### Minor Changes
+
+- Framework-agnostic core. The **package root `@plitzi/nexus` is now the agnostic core** (zero React): `createStore`,
+  imperative `get/set/watch`, middlewares, and the async/derived/entities primitives. React bindings live in
+  `@plitzi/nexus/react` (`StoreProvider`, `createStoreHook`, all hooks, `useEntity`); Next.js helpers in
+  `@plitzi/nexus/next`. Source is organized to match: `src/react/`, `src/next/`, and the agnostic modules at the top
+  level.
+- Removed the Vite-only `import.meta.env.MODE`; dev/prod/test detection now uses `process.env.NODE_ENV`, so the
+  dev-only warnings behave identically under webpack, esbuild, Rollup, Bun, raw Node and Vite/Astro.
+- Added a first-class **Vue 3 integration** at `@plitzi/nexus/vue`: `provideStore` / `injectStore`, `useStore`
+  (writable ref / `v-model`), `useStoreValue`, `createStoreComposable`, `useEntity*`, `useDerived`, `useAsync`, and
+  `useStoreHistory`. `vue` is an optional peer dependency (`^3.4`).
+- Added runnable examples (`examples/`) and integration docs (`docs/integrations/`) for React, Next.js, Astro 6 (LTS),
+  Astro 7, Vue and Svelte.
+
+### Breaking Changes
+
+- **React bindings moved out of the root.** Import `StoreProvider`, `createStoreHook`, `useStore`, `useStoreHistory`,
+  etc. from `@plitzi/nexus/react` instead of `@plitzi/nexus` (or the old `/createStore`, `/StoreProvider`,
+  `/StoreContext` subpaths). The root now exports only the agnostic core. Agnostic symbols (`createStore`, middlewares,
+  `createServerSnapshot`, types) stay on the root.
+- `createEntityStore` is now framework-agnostic and no longer exposes `useOne` / `useIds` / `useAll` on the returned
+  object. Use the React bindings instead: `const { useOne, useIds, useAll } = useEntity(store)`, or the standalone
+  `useEntityOne(store, id)` / `useEntityIds(store)` / `useEntityAll(store)` from `@plitzi/nexus/react`.
+
 ## 0.32.1
 
 ### Patch Changes

package/README.md

@@ -1,17 +1,34 @@
 <p align="center">
-  <img src="./logo.svg" alt="@plitzi/nexus" width="640" />
+  <img src="./logo.svg" alt="@plitzi/nexus — one store, every framework" 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). Fully compatible with SSR, React Server Components, and Next.js App Router.
+A lightweight, type-safe state store with a **framework-agnostic core** and first-class React bindings, 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, Next.js App Router, and Astro (6 LTS & 7) islands.
+
+## Entry points
+
+The **package root is the framework-agnostic core** (zero React). Framework bindings live in their own entries.
+
+| Import | What it is |
+|---|---|
+| `@plitzi/nexus` | **Agnostic core** — `createStore`, imperative `get/set/watch`, middlewares, async/derived/entities. Zero React. |
+| `@plitzi/nexus/advanced` | The opt-in add-ons (`async`, `derived`, `entities`, `history`, `middleware`) re-exported in one place, kept off the root so root autocomplete stays focused on the core. |
+| `@plitzi/nexus/react` | React bindings — `StoreProvider`, `createStoreHook`, `useStore`, `useStoreHistory`, `useEntity`, `useAsync`, `useDerived`, … |
+| `@plitzi/nexus/vue` | Vue 3 bindings — `provideStore`, `useStore` (writable ref), `useStoreValue`, `useEntity`, `useStoreHistory`, … |
+| `@plitzi/nexus/next` | Next.js App Router helpers (`bindServerAction`). |
+| `@plitzi/nexus/rsc` | Server Component → Client handoff markers (`createServerSnapshot`, `isServerSnapshot`, `stripServerFlag`). Also re-exported from the root. |
+
+Any other framework works by talking to the root directly (`store.subscribe` / `store.getState`) — see the Svelte
+[example](./examples/svelte). For Astro, see [docs/integrations/astro.md](./docs/integrations/astro.md).
 
 ```bash
-npm install @plitzi/nexus   # peer deps: react@^18 || ^19, react-dom@^18 || ^19
+npm install @plitzi/nexus   # React bindings peer deps: react@^18 || ^19, react-dom@^18 || ^19
 ```
 
 ```ts
-import { createStoreHook } from '@plitzi/nexus';
+// React: hooks come from the /react entry
+import { createStoreHook } from '@plitzi/nexus/react';
 
 type State = { count: number; user: { name: string } };
 const { useStore } = createStoreHook<State>();
@@ -62,7 +79,7 @@ Also importable from the focused `@plitzi/nexus/advanced` entry point, which kee
 | `createDerived` / `useDerived` | A memoized value computed from store paths (reselect-style). |
 | `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. |
+| `loggerMiddleware` / `persistMiddleware` / `historyMiddleware` / `reduxDevToolsMiddleware` / `createRecorder` | Middlewares: log, persist to storage, record time-travel, connect to Redux DevTools, buffer recent changes for a custom dev-tools panel. |
 | `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` / `isServerSnapshot` | Mark server-fetched data for RSC → Client handoff, and check the marker. |
@@ -70,21 +87,27 @@ Also importable from the focused `@plitzi/nexus/advanced` entry point, which kee
 
 ## Architecture
 
+The package root is the **framework-agnostic core**; React, Vue, and Next bindings are physically separate
+entries that depend on it (never the other way round), so the core ships zero framework code.
+
 ```
-StoreContext.ts          context object (no deps → no cycles)
-createStore.ts           factory + createStoreHook
-StoreProvider.tsx        context provider with optional sync
-hooks/
-  useStore.ts            subscribe + read
-  useStoreSync.ts        sync external value into the store (write-only)
-  useStoreGetter.ts      non-reactive snapshot getter
-  useStoreSetter.ts      fire-and-forget setter
-  shared.ts              snapshot factories, subscription helpers
-derived/                 createDerived + useDerived (memoized computed values)
-entities/                createEntityAdapter (normalized-map CRUD + selectors)
-middleware/              logger / persist / history (all on subscribeChange)
-history/                 getStoreHistory + useStoreHistory (time-travel, enabled by historyMiddleware)
-helpers/                 getByPath, setByPath, parsePath, shallowEqual…
+src/
+  index.ts               agnostic core barrel (createStore, middlewares, async/derived/entities, rsc)
+  createStore/           store factory + scope chain / write engine
+    createStore.ts         factory (get/set/watch + getState/setState/subscribe…)
+    helpers/               writeByPath (codegen), deepMerge, scope reads, PathTrie, Subscribers…
+  derived/               createDerived (memoized computed values)
+  entities/              createEntityAdapter (map CRUD) + createEntityStore (reactive O(1) per item)
+  async/                 createAsync (race-safe fetch landed on a path)
+  middleware/            logger / persist / history / reduxDevTools / cascade (all on subscribeChange)
+  history/               getStoreHistory (time-travel handle, enabled by historyMiddleware)
+  rsc/                   createServerSnapshot / isServerSnapshot / stripServerFlag
+  helpers/               getByPath, setByPath, parsePath, shallowEqual, isPathAffected…
+  types/                 StoreTypes.ts — every public type
+  advanced/              curated barrel re-exporting async + derived + entities + history + middleware
+  react/                 StoreProvider, StoreContext, createStoreHook, hooks/* (useStore, useEntity, useAsync…)
+  vue/                   provideStore/injectStore + composables (useStore, useEntity, useDerived, useAsync…)
+  next/                  bindServerAction (App Router server actions)
 ```
 
 > **One change substrate.** Every committed write flows through `store.subscribeChange((change) => …)` where `change` is `{ path, prev, next }`. `loggerMiddleware`, `persistMiddleware`, and `historyMiddleware` are all just observers on this channel — and so is any middleware you write. It costs nothing on the hot path when no observer is attached. Writes can also be **intercepted** before they commit via a middleware's `beforeChange` to transform or cancel them — see [Intercepting writes](#intercepting-writes-beforechange).
@@ -253,8 +276,8 @@ const [state, setState] = useStore();
 // Single path
 const [name, setName] = useStore('user.name');
 
-// With default value
-const [el, setEl] = useStore(`schema.flat.${id}` as PathOf<MyState>, { defaultValue: {} });
+// Fallback for a possibly-undefined value — destructure a default (no `defaultValue` option):
+const [el = {}] = useStore(`schema.flat.${id}` as PathOf<MyState>);
 
 // Dynamic path (function resolves the path string at runtime)
 const [val, setVal] = useStore(s => `style.platform.${s.displayMode}` as PathOf<MyState>);
@@ -413,6 +436,73 @@ createEntityAdapter<Row>({ selectId: r => r.key, sortComparer: (a, b) => a.name.
 
 Ops: `addOne/addMany` (ignore existing), `setOne/setMany/setAll` (replace), `updateOne/updateMany` (merge changes), `upsertOne/upsertMany` (add or merge), `removeOne/removeMany/removeAll`. Each returns the **same map reference** when nothing changed, so the store skips the write.
 
+## `createEntityStore` (reactive, O(1) per item)
+
+**What it's for:** the same normalized collection, but as a **standalone reactive store** that notifies *per item*. Where `createEntityAdapter` lives inside a `StoreApi` path (one map, one subscription — every consumer wakes when any item changes), `createEntityStore` lets a row subscribe to **just its own id**, so editing one item re-renders only that row, not the list. Use it for large lists / tables where the adapter's whole-map churn shows up.
+
+```ts
+import { createEntityStore } from '@plitzi/nexus';
+
+const todos = createEntityStore<Todo>({ selectId: t => t.id });
+
+todos.setMany([a, b, c]);
+todos.updateOne('a', { done: true });
+todos.removeOne('b');
+
+todos.getOne('a');                              // Todo | undefined
+todos.getIds();                                 // string[]
+todos.getAll();                                 // Todo[]
+const off = todos.subscribeOne('a', render);    // wakes ONLY when item 'a' changes
+```
+
+React — subscribe at the granularity you actually render at:
+
+```tsx
+import { useEntity, useEntityIds, useEntityOne } from '@plitzi/nexus/react';
+
+function List() {
+  const ids = useEntityIds(todos);              // re-renders only on add/remove
+  return ids.map(id => <Row key={id} id={id} />);
+}
+
+function Row({ id }: { id: string }) {
+  const todo = useEntityOne(todos, id);         // re-renders only when THIS item changes
+  return <li>{todo?.text}</li>;
+}
+
+// Or the bound shape: const { useOne, useIds, useAll } = useEntity(todos);
+```
+
+## `createAsync` / `useAsync` (race-safe fetch)
+
+**What it's for:** a fetch whose result lands on a store path, with status tracking and last-write-wins race safety, shared across every consumer. Read it inline (loading / error UI) with `useAsync`, or unwrap the value (Suspense) with `useAsyncValue`.
+
+```ts
+import { createAsync } from '@plitzi/nexus';
+
+const user = createAsync(store, 'user', async (id: string) => fetchUser(id));
+user.run('42');                                 // kicks off; a newer run() supersedes an in-flight one
+user.get();                                     // { status, data, error }
+```
+
+```tsx
+import { useAsync, useAsyncValue } from '@plitzi/nexus/react';
+
+function Profile() {
+  const { status, data, error } = useAsync(user); // re-renders on status / value change
+  if (status === 'pending') { return <Spinner />; }
+
+  return <span>{data?.name}</span>;
+}
+
+// Suspense form — throws the promise while pending, returns the value when settled:
+function ProfileSuspense() {
+  const data = useAsyncValue(user);
+
+  return <span>{data.name}</span>;
+}
+```
+
 ## Middleware (`loggerMiddleware` / `persistMiddleware` / `historyMiddleware`)
 
 **What it's for:** cross-cutting logic on every write, centralized in one place. A middleware is `(api) => { beforeChange?, onChange? } | void`; its setup body runs once after creation (so it can hydrate). It can do two things: **intercept** a write before it commits (`beforeChange`) and **observe** a write after it commits (`onChange`, the `{ path, prev, next }` change). logger, persist, and history are built-in observers; write your own the same way. Middlewares are per-store — in a scope chain, attach them where the writes you care about commit (shared keys delegate to the owning scope, so the owning scope's interceptors run).
@@ -437,6 +527,23 @@ const analytics: StoreMiddleware<State> = api => ({
 const off = store.subscribeChange(({ path, prev, next }) => {});
 ```
 
+### `cascade` — share a middleware with nested scopes
+
+Middlewares are per-store, so a nested `StoreProvider` (or scoped `createStore`) doesn't inherit the parent's
+middlewares by default. Wrap one in `cascade()` to have every descending store get its **own instance** of it —
+set a logger or analytics sink once at the root instead of repeating it in each child.
+
+```ts
+import { createStore, cascade, loggerMiddleware } from '@plitzi/nexus';
+
+const root = createStore<State>(initial, {
+  middlewares: [cascade(loggerMiddleware())] // child scopes log too, each with its own instance
+});
+```
+
+Storage- or recorder-bound middlewares (`persistMiddleware`, `historyMiddleware`) are deliberately **not**
+cascaded — they're per-store by nature (one storage key, one recorder). Only mark them if you really mean it.
+
 ### Intercepting writes (`beforeChange`)
 
 `onChange` only **observes** committed changes — it can't stop or rewrite them. A middleware's `beforeChange` runs **before** the write commits and can transform the value, or cancel the write entirely by returning `CANCEL`. Returning `undefined` lets the value through unchanged. It's just another middleware, so you write your own the same way you'd write a logger.
@@ -514,6 +621,26 @@ reduxDevToolsMiddleware<State>({
 
 Intended for the root store; like `persist`/`history` it's per-store and not cascaded.
 
+### `createRecorder`
+
+A ready-to-use change recorder for building your **own** dev-tools UI — a bounded, subscribable log of committed writes (`{ seq, time, path, prevValue, nextValue }`). Unlike `loggerMiddleware` (fire-and-forget to a sink) it retains recent history and lets a UI read/subscribe; unlike `reduxDevToolsMiddleware` it needs no browser extension. The `getEntries` snapshot is reference-stable between records, so it drops straight into `useSyncExternalStore`.
+
+```tsx
+import { createStore, createRecorder } from '@plitzi/nexus';
+import { useSyncExternalStore } from 'react';
+
+const recorder = createRecorder<State>({ max: 100 });
+const store = createStore<State>(initial, { middlewares: [recorder.middleware] });
+
+function ChangesPanel() {
+  const entries = useSyncExternalStore(recorder.subscribe, recorder.getEntries);
+
+  return entries.map(e => `${e.path}: ${JSON.stringify(e.prevValue)} → ${JSON.stringify(e.nextValue)}`);
+}
+```
+
+`entriesSince(seq)` / `lastSeq()` correlate writes with an external timeline (e.g. "which writes happened since the last render commit"); `record(change)` feeds it directly so one shared recorder can collect from several stores. Per-store, not cascaded.
+
 ## Time-travel (`historyMiddleware`)
 
 Records an action log you can undo / redo / jump through. Enable it by adding `historyMiddleware()` to the store; read it reactively with `useStoreHistory`, or imperatively with `getStoreHistory(store)` (which returns the handle the middleware registered, or `undefined` when it isn't enabled). Without the middleware, `useStoreHistory` returns an empty, no-op view.
@@ -749,6 +876,38 @@ function Likes({ store, updateLikes }: { store: StoreApi<State>; updateLikes: Se
 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.
 
+## Vue 3 (`@plitzi/nexus/vue`)
+
+The same agnostic core, bound to Vue's reactivity via `provide`/`inject` and composables that return refs.
+Provide a store at a parent, then bind a path two-ways with `useStore` (write through `ref.value` or `v-model`),
+or read-only with `useStoreValue`.
+
+```vue
+<!-- App.vue -->
+<script setup lang="ts">
+import { provideStore } from '@plitzi/nexus/vue';
+
+type State = { count: number; user: { name: string } };
+provideStore<State>({ count: 0, user: { name: 'Ada' } });
+</script>
+
+<!-- Counter.vue -->
+<script setup lang="ts">
+import { useStore, useStoreValue } from '@plitzi/nexus/vue';
+
+const count = useStore<State, 'count'>('count'); // WritableComputedRef — re-renders only on change
+const name = useStoreValue<State, 'user.name'>('user.name'); // read-only ref
+</script>
+
+<template>
+  <button @click="count++">{{ name }}: {{ count }}</button>
+</template>
+```
+
+`createStoreComposable<State>()` mirrors React's `createStoreHook` — it returns `useStore` / `useStoreValue` /
+`useStoreState` already bound to `State`. Vue also ships `useEntity`, `useDerived`, `useAsync`, and
+`useStoreHistory` composables matching their React counterparts.
+
 ## 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.
@@ -776,7 +935,7 @@ All types live in `src/types/StoreTypes.ts`:
 | `EntityAdapter<T>` | CRUD updaters + selectors from `createEntityAdapter` |
 | `EntityUpdater<T>` | `(map) => map` — an immutable entity-map update for `setState` |
 | `SetState<T>` | Full `setState` overload signature |
-| `UseStoreOptions` | Options for `useStore` (mode, enabled, equalityFn, defaultValue, transformer) |
+| `UseStoreOptions` | Options for `useStore` (mode, enabled, equalityFn, transformer, store, storeId) |
 | `UseStoreMultiOptions` | Options for multi-path `useStore` |
 | `UseStoreSyncOptions` | Options for `useStoreSync` (mode, enabled, syncStrategy) |
 | `UseStoreSyncMultiOptions` | Options for multi-path `useStoreSync` |

package/dist/advanced/index.d.ts

@@ -1,5 +1,3 @@
-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';

package/dist/advanced/index.mjs

@@ -1,16 +1,10 @@
-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 };
+import { createAsync as e } from "../async/createAsync.mjs";
+import { createDerived as t } from "../derived/createDerived.mjs";
+import { createEntityAdapter as n } from "../entities/createEntityAdapter.mjs";
+import { createEntityStore as r } from "../entities/createEntityStore.mjs";
+import { getStoreHistory as i, historyMiddleware as a } from "../middleware/historyMiddleware.mjs";
+import { loggerMiddleware as o } from "../middleware/loggerMiddleware.mjs";
+import { persistMiddleware as s } from "../middleware/persistMiddleware.mjs";
+import { reduxDevToolsMiddleware as c } from "../middleware/reduxDevToolsMiddleware.mjs";
+import { cascade as l } from "../middleware/cascade.mjs";
+export { l as cascade, e as createAsync, t as createDerived, n as createEntityAdapter, r as createEntityStore, i as getStoreHistory, a as historyMiddleware, o as loggerMiddleware, s as persistMiddleware, c as reduxDevToolsMiddleware };

package/dist/async/index.d.ts

@@ -1,4 +1,2 @@
 export { createAsync } from './createAsync';
-export { useAsync } from './hooks/useAsync';
-export { useAsyncValue } from './hooks/useAsyncValue';
 export type { AsyncOptions, AsyncResource, AsyncSnapshot, AsyncStatus } from './createAsync';

package/dist/async/index.mjs

@@ -1,4 +1,2 @@
 import { createAsync as e } from "./createAsync.mjs";
-import { useAsync as t } from "./hooks/useAsync.mjs";
-import { useAsyncValue as n } from "./hooks/useAsyncValue.mjs";
-export { e as createAsync, t as useAsync, n as useAsyncValue };
+export { e as createAsync };

package/dist/createStore/createStore.d.ts

@@ -1,7 +1,9 @@
-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';
+import { GetState, SetState, StoreApi, StoreMiddleware } from '../types';
 export type CreateStoreOptions<TState extends object> = {
     id?: string;
+    scopePath?: string;
     parent?: StoreApi<TState>;
+    exclusive?: ReadonlyArray<string>;
     middlewares?: StoreMiddleware<TState>[];
     /** When true, hydrate handlers are collected but NOT run during creation.
      *  Call `store.hydrate()` manually (StoreProvider does this in a useEffect).
@@ -9,46 +11,4 @@ export type CreateStoreOptions<TState extends object> = {
     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?: UseStoreOptions<PathValue<TState, P>, TState> & {
-            transformer?: never;
-        }): [PathValue<TState, P>, (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?: UseStoreOptions<PathValue<TState, P>, TState> & {
-            transformer?: never;
-        }): [PathValue<TState, P>, 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>, "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>, "transformer"> & {
-            transformer?: never;
-        }): [PathOrFnValues<TState, Entries>, ...PathOrFnSetters<TState, Entries>];
-        <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>];
-    };
-    useStoreSync: {
-        (path: undefined, value: TState | Partial<TState>, options?: UseStoreSyncOptions<TState, TState>): void;
-        <P extends PathOf<TState>>(path: P | ((state: TState) => P), value: PathValue<TState, P>, options?: UseStoreSyncOptions<PathValue<TState, P>, TState>): void;
-        <const Paths extends ReadonlyArray<PathOf<TState>>>(paths: Paths, values: PathValues<TState, Paths>, options?: UseStoreSyncMultiOptions<TState>): void;
-        (paths: ReadonlyArray<PathOrFn<TState>>, values: readonly unknown[], options?: UseStoreSyncMultiOptions<TState>): void;
-    };
-    useStoreGetter: {
-        (options?: UseStoreGetterOptions<TState>): GetValueFn<TState>;
-        <P extends PathOf<TState>>(basePath: P, options?: UseStoreGetterOptions<TState>): GetValueFromBaseFn<PathValue<TState, P>>;
-        <const Entries extends ReadonlyArray<PathOf<TState> | ((state: TState) => unknown)>>(entries: Entries, options?: UseStoreGetterOptions<TState>): GetterTuple<TState, Entries>;
-    };
-    useStoreSetter: {
-        (options?: UseStoreSetterOptions<TState>): SetStateFn<TState>;
-        <P extends PathOf<TState>>(basePath: P, options?: UseStoreSetterOptions<TState>): SetFromBaseFn<PathValue<TState, P>>;
-    };
-};
 export default createStore;

package/dist/createStore/createStore.mjs

@@ -1,131 +1,107 @@
-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 o from "./hooks/useStore.mjs";
-import s from "./hooks/useStoreGetter.mjs";
-import c from "./hooks/useStoreSync.mjs";
+import e from "./helpers/Subscribers.mjs";
+import { isDev as t, isTest as n } from "../env.mjs";
+import { createChainReads as r } from "./helpers/createChainReads.mjs";
+import { createSetState as i } from "./helpers/createSetState.mjs";
+import { forwardParentChanges as a } from "./helpers/forwardParentChanges.mjs";
+import o from "./helpers/PathTrie.mjs";
+import { createScopeClaims as s } from "./helpers/scopeCollisions.mjs";
 //#region src/createStore/createStore.ts
-var l = 0;
-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) => {
-		if (g.length === 0) throw e;
+var c = 0;
+function l(l, u) {
+	let d = {}, f, p = new e(), m = new e(), h = new o(), g = new e(), _ = () => {
+		g.length !== 0 && g.forEach((e) => e());
+	}, v = [], y = [], b = [], x = u?.parent, S = ++c, C = (e, t, n) => {
+		if (y.length === 0) throw e;
 		let r = {
 			error: e,
 			phase: t,
 			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, 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,
+		for (let e = 0, t = y.length; e < t; e++) y[e](r);
+	}, w = () => d, T = () => f ??= { ...d }, { getState: E, getPath: D, invalidate: O, resetCache: k, getMergeCount: A } = r(w, T, x, u?.exclusive), j = () => {
+		O(), _();
+	}, M, N, P = !1;
+	x && (k(), N = x.subscribeInvalidate?.(j));
+	let { setState: F, batch: I } = i({
+		getOwnState: w,
+		getOwnSnapshot: T,
 		setOwnState: (e) => {
-			s = e, c = void 0, w();
+			d = e, f = void 0, O();
 		},
 		mutateOwnKey: (e, t) => {
-			s[e] = t, w(), c = void 0;
+			d[e] = t, O(), f = void 0;
 		},
-		parent: v,
-		listeners: u,
-		pathListeners: f,
-		changeListeners: d,
-		interceptors: h,
-		reportError: y,
-		invalidateDescendants: m,
-		onDelegateToParent: void 0
-	}), 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 = () => {
-		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;
+		parent: x,
+		listeners: p,
+		pathListeners: h,
+		changeListeners: m,
+		interceptors: v,
+		reportError: C,
+		invalidateDescendants: _,
+		onDelegateToParent: t && x ? (e) => x.scopeClaims?.claimDelegatedWrite(e, S) : void 0
+	}), L = () => p.length > 0 || h.size > 0 || m.length > 0, R = () => {
+		M || !x || (O(), k(), M = a(x, p, h, m, E, C, O), m.length > 0 && M.seedBaseline());
+	}, z = () => {
+		M && (M.unsubscribe(), M = void 0, k());
+	}, B = () => {
+		x && (!P && L() ? R() : z());
+	}, V = (e) => (B(), () => {
+		e(), B();
+	}), H = (e) => V(p.add(e)), U = (e, t) => V(h.add(e, t)), W = (e) => {
+		let t = V(m.add(e));
+		return M?.seedBaseline(), t;
 	};
-	s = typeof e == "function" ? e(j, S) : e;
-	let V = {
-		id: o?.id,
-		getState: S,
-		getPath: C,
-		setState: j,
-		get: ((e) => e === void 0 ? S() : C(e)),
-		set: j,
-		watch: ((e, t) => typeof e == "function" ? R(e) : z(e, t)),
+	d = typeof l == "function" ? l(F, E) : l;
+	let G = {
+		id: u?.id,
+		scopePath: u?.scopePath,
+		getState: E,
+		getPath: D,
+		setState: F,
+		get: ((e) => e === void 0 ? E() : D(e)),
+		set: F,
+		watch: ((e, t) => typeof e == "function" ? H(e) : U(e, t)),
 		withBase: (e) => {
-			let t = (t, n) => j(t === void 0 ? e : `${e}.${t}`, n);
+			let t = (t, n) => F(t === void 0 ? e : `${e}.${t}`, n);
 			return {
 				getState: (t) => {
-					let n = C(e);
+					let n = D(e);
 					return n === void 0 && t !== void 0 ? t : n;
 				},
 				getPath: (t, n) => {
-					let r = C(`${e}.${t}`);
+					let r = D(`${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}`),
+				subscribe: (t) => U(e, t),
+				subscribePath: (t, n) => U(`${e}.${t}`, n),
+				get: (t) => D(t === void 0 ? e : `${e}.${t}`),
 				set: t,
-				watch: (t, n) => typeof t == "function" ? z(e, t) : z(`${e}.${t}`, n)
+				watch: (t, n) => typeof t == "function" ? U(e, t) : U(`${e}.${t}`, n)
 			};
 		},
-		batch: M,
-		subscribe: R,
-		subscribePath: z,
-		subscribeChange: B,
+		batch: I,
+		subscribe: H,
+		subscribePath: U,
+		subscribeChange: W,
 		destroy: () => {
-			A = !0, F(), u.clear(), f.clear(), d.clear(), p.clear(), k?.();
+			P = !0, z(), p.clear(), h.clear(), m.clear(), g.clear(), N?.();
 		},
 		reconnect: () => {
-			A = !1, v && (k?.(), k = v.subscribeInvalidate?.(D)), I();
+			P = !1, x && (N?.(), N = x.subscribeInvalidate?.(j)), B();
 		},
-		subscribeInvalidate: (e) => p.add(e),
+		subscribeInvalidate: (e) => g.add(e),
 		hydrate: () => {
-			for (let e of _) e();
+			for (let e of b) e();
 		}
 	};
-	if (o?.middlewares) for (let e of o.middlewares) {
-		let t = e(V);
-		t?.beforeChange && h.push(t.beforeChange), t?.onChange && B(t.onChange), t?.onError && g.push(t.onError);
+	if (u?.middlewares) for (let e of u.middlewares) {
+		let t = e(G);
+		t?.beforeChange && v.push(t.beforeChange), t?.onChange && W(t.onChange), t?.onError && y.push(t.onError);
 		let n = t?.hydrate;
-		n && (o.deferHydrate ? _.push(() => n(V)) : n(V));
+		n && (u.deferHydrate ? b.push(() => n(G)) : n(G));
 	}
-	return V;
+	return t && (G.scopeClaims = s()), n && (G.listeners = p, G.pathListeners = h, G.changeListeners = m, G.interceptors = v, G.errorHandlers = y, G.invalidateListeners = g, G.getMergeCount = A), G;
 }
-var d = () => {
-	function t(e, t) {
-		return o(e, t);
-	}
-	function n(e, t, n) {
-		c(e, t, n);
-	}
-	function r(e, t) {
-		return s(e, t);
-	}
-	function i(t, n) {
-		return e(t, n);
-	}
-	return {
-		useStore: t,
-		useStoreSync: n,
-		useStoreGetter: r,
-		useStoreSetter: i
-	};
-};
 //#endregion
-export { d as createStoreHook, u as default };
+export { l as default };