@plitzi/nexus 0.32.0 → 0.32.2

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # @plitzi/nexus
 
+## 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
+
+- v0.32.1
+
 ## 0.32.0
 
 ### Minor 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>();
@@ -22,44 +39,75 @@ 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. |
-| `loggerMiddleware` / `persistMiddleware` / `historyMiddleware` / `reduxDevToolsMiddleware` | Middlewares: log, persist to storage, record time-travel, connect to Redux DevTools. |
+| `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` / `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` | 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
 
+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).
@@ -228,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>);
@@ -388,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).
@@ -412,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.
@@ -489,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.
@@ -724,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.
@@ -751,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

@@ -0,0 +1,5 @@
+export * from '../async';
+export * from '../derived';
+export * from '../entities';
+export * from '../history';
+export * from '../middleware';

package/dist/advanced/index.mjs

@@ -0,0 +1,10 @@
+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;