createNexuscreateReactNexus (from nexus-state/react)createNexusoptions: object with state and optional acts.createActsacts, or pass several slices as an array.create: function that receives get and set, with this bound to the full acts object.persistsource: \"storage\", and the write-back skips updates carrying that\nsource — so loading from disk never echoes back to disk. Returns a function that\nstops persisting.persist because that is the user intent. The\nstorage adapter itself is synchronous and string-based: it works with\nlocalStorage, sessionStorage, or a custom object that\nimplements getItem, setItem and\nremoveItem.nexus: the store to persist.options.key: storage key.options.storage: storage backend (defaults to localStorage; no-op when unavailable).options.include: choose which keys to persist (defaults to all).options.version + options.migrate: migrate older snapshots.options.debounce: ms to coalesce rapid updates into one write (flushed on cleanup / pagehide). Omit for immediate writes.options.onError: handle storage / parse errors instead of throwing.persist and write it with context:\n\n```ts\nconst profile = await loadProfile();\nnexus.set({ profile }, { source: \"server\" });\n```\n\ncreateReactNexuscreateNexus with React-specific hooks.options: object with state and optional acts.getkey: optional state name.setset notifies once.update: partial state, or (state) => partial.context: optional provenance — a string or { source, meta }. Travels to middleware and subscribers.@@ are reserved for the library.set with several keys notifies once — the primary way to batch. set calls made synchronously inside an action are collapsed into one too.\n\nreset{ source: \"reset\" }.subscribeobserver: (state, context?) => void, called when a watched key changes.dependencies: keys to watch (required, so every subscription is explicit). Pass specific keys, or [\"*\"] to watch every key.middlewarefn: (prev, next, context?) => next | void. Return a new state to replace it, or nothing for a side effect only.actsset makes inside an action inherit the\n> action name as their source (unless the set\n> passes its own context), so subscribers, persist and devtools can\n> tell which action changed the state. Nested this.other() calls keep\n> the outer action's name.\n\nImportant:this, arrow functions are more compact but don't:\nusereact hook to subscribe to the entire state or a single value.key: optional state name.useSelectorreact hook that derives a value from state. The keys the selector\nreads are tracked automatically — the component subscribes to exactly\nthose keys, with no dependency array to keep in sync. It re-renders only when the\nselector's result changes (Object.is by default).selector: derives a value from the state. The keys it reads are auto-tracked.isEqual: optional result comparator — \"shallow\" for built-in one-level equality, or your own (a, b) => boolean. Defaults to Object.is.selector argument, not\n> nexus.get() — reads that bypass the argument aren't tracked.useCallback is needed.\n\nuseRerenderreact hook that returns a function to force a re-render.nexus-state/devtoolssource (so\nyou see where each change came from), with time-travel. Updates made inside\nan acts action are labelled by the action name automatically —\nno manual source needed. A no-op when the extension isn't installed,\nso it's safe to leave in.nexus: the store to inspect.options.name: instance name in the DevTools dropdown.options.enabled: set false to disable (e.g. in production).set in one line: set(produce(get(), recipe)). Mutate a\ndraft, get an immutable update, no manual spreading. And because set\ndiffs by reference and Immer's structural sharing keeps untouched branches, only\nthe keys you actually change notify their subscribers.npm i immer. Then wrap any\nupdate in produce(get(), …) and mutate the draft freely — assign,\npush, splice, delete. The draft is your typed state, so you decide what to change:\n\n```ts\nimport { createNexus } from \"nexus-state\";\nimport { produce } from \"immer\";\n\nconst nexus = createNexus({\n state: {\n /* any shape, however nested */\n },\n acts: (get, set) => ({\n // one action can change anything on the draft:\n update() {\n set(\n produce(get(), (s) => {\n // s is your typed state — mutate whatever you need:\n // s.a.b.c = value;\n // s.list.push(item);\n // delete s.map[id];\n }),\n );\n },\n }),\n});\n\n// Outside an action it's the same one-liner:\nnexus.set(\n produce(nexus.get(), (s) => {\n // mutate the draft\n }),\n);\n```\n\n