@reactra/store 0.1.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Akhil Shastri and the Reactra contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,17 @@
+# @reactra/store
+
+> Reactra store runtime — scoped, fine-grained, per-field-subscription state for Reactra apps.
+
+**Alpha** — published under the npm dist-tag `alpha`. APIs may change before 1.0.
+
+```bash
+npm install @reactra/store@alpha
+```
+
+Part of [Reactra](https://github.com/akhilshastri/reactra) — a compiler-first,
+React-19-compatible framework. See the [documentation](https://reactra-docs.vercel.app) to get
+started.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1,357 @@
+/**
+ * Per-store runtime instance. Compiler-emitted factories build one of these
+ * via `createStoreInstance` and hand it to the registry. The factory closure
+ * owns the state vars; the instance just exposes the subscribe + getSnapshot
+ * pair that `useSyncExternalStore` needs.
+ */
+export interface StoreInstance<T extends Record<string, unknown> = Record<string, unknown>> {
+    /** Subscribe to all changes. Returns an unsubscribe fn. */
+    subscribe: (onChange: () => void) => () => void;
+    /**
+     * Return the current snapshot — a stable object reference until the next
+     * `notify()` call. `useSyncExternalStore` relies on referential stability
+     * to avoid infinite re-renders.
+     *
+     * `T` is the store's public surface (state + derived + actions). The
+     * compiler-emitted factory infers it from the snapshot composer, which is
+     * how `StoreSurface` recovers the precise type for `export type <store>`
+     * (Store §2.5). Defaults to `Record<string, unknown>` so hand-written /
+     * untyped callers keep working.
+     */
+    getSnapshot: () => T;
+    /**
+     * Internal — fan out the current snapshot to all subscribers. Used by
+     * `StoreRegistry.replace` during HMR to wake old subscribers after a
+     * factory swap so their next render reads the new instance from the
+     * registry. User code (and compiler-emitted action bodies) call notify
+     * through the closure parameter passed to `createStoreInstance.build`,
+     * not via this field.
+     */
+    notify: () => void;
+}
+/** Lifecycle kind that determines when a store's factory runs. */
+export type StoreBindingKind = "export" | "session" | "route";
+/**
+ * The shape a compiler-emitted store binding takes: a `{ name, kind, factory }`
+ * tuple the user passes to `configureStores`. The factory's `inputs` parameter
+ * is only meaningful for route stores (the router passes URL-derived values
+ * mapped via argumented `use storeX(param a, query b)`). Export and session
+ * stores ignore it.
+ */
+export interface StoreBinding {
+    name: string;
+    /**
+     * "export" / "session" → instantiate eagerly at `configureStores` time.
+     * "route" → register the factory but wait for `StoreRegistry.instantiate`
+     *           to fire on route enter.
+     */
+    kind: StoreBindingKind;
+    /**
+     * Wave 3 §2b — `route store ... for subtree "/path"`. When set, this store
+     * survives across every route whose pathname starts with the subtree path.
+     * `instantiate(name, ...)` is a NO-OP when an instance is already live;
+     * `dispose(name, { nextPathname })` is a no-op when `nextPathname` is still
+     * inside the subtree. Both checks isolate subtree-aware behaviour to
+     * stores that opt in via this field — non-subtree stores keep their
+     * existing per-route lifecycle.
+     */
+    subtreePath?: string;
+    /**
+     * Builds an instance. `inputs` is route-derived (argumented `inject store`).
+     * `restored` (route stores with `preserved state`) carries the values read
+     * back from `sessionStorage` — the compiler-emitted factory overwrites the
+     * matching `state` fields from it (Store §6). Both optional + ignored by
+     * stores that don't use them, so existing factories are unaffected.
+     */
+    factory: (inputs?: Record<string, unknown>, restored?: Record<string, unknown>) => StoreInstance;
+    /**
+     * State field names listed under `preserved state X, Y` (Store §6) — the
+     * compiler emits this on the binding. The registry persists exactly these
+     * fields on route exit and reads them back into `restored` on the next enter.
+     */
+    preservedFields?: readonly string[];
+    /**
+     * Stage E (Resource v1 §8) — compiler-emitted prefetch warmer. For a route
+     * store with `resource r(deps) => fn(deps)` declarations, the compiler emits
+     * a `warm(inputs, signal)` companion that calls `warmResource(name, deps,
+     * fn, signal)` once per resource (parallel `Promise.all`). Best-effort: the
+     * returned promise resolves silently on any failure (RES015 was deliberately
+     * not minted — failed warms are debug-only). Stores without resources omit
+     * this field; `StoreRegistry.warm` treats absence as a no-op.
+     */
+    warm?: (inputs: Record<string, unknown> | undefined, signal: AbortSignal) => Promise<void>;
+}
+/**
+ * The public surface type of a compiler-emitted store binding — its state,
+ * derived, and action members (inputs are excluded; they are factory
+ * parameters, not part of the snapshot). Pass 9 emits, alongside each store
+ * binding, `export type <name> = StoreSurface<typeof <name>>` (Store §2.5) so
+ * a consumer's `import type { <name> }` resolves the live surface through
+ * native module resolution.
+ *
+ * It stays in lockstep with the store body **by construction**: the type is
+ * inferred from the same factory the runtime executes, so it cannot drift the
+ * way a hand-maintained interface would. This is what lets store linkage
+ * survive package boundaries (the `.reactra.json` sidecar does not — see
+ * Compiler §6) and is the prerequisite for retiring the implicit sidecar-index
+ * name resolution (backlog 1a).
+ */
+export type StoreSurface<B extends {
+    factory: (...args: never[]) => StoreInstance;
+}> = ReturnType<B["factory"]> extends StoreInstance<infer T> ? T : never;
+/**
+ * Route-entry coordinates that key a preserved-state slot (Store §6 / Router
+ * §8.4). Two distinct entries to the same route (different params/query) get
+ * distinct slots, so e.g. `/checkout?u=1` and `/checkout?u=2` don't leak.
+ */
+export interface PreservedKey {
+    pathname: string;
+    params: Record<string, unknown>;
+    query: Record<string, unknown>;
+}
+/**
+ * Internal/diagnostics tier (Runtime §3) — register a store's restore closure.
+ * Compiler-emitted (Pass 9); last-wins per name. Mirrors `__listStoreBindings`.
+ * The closure returns the **count of state fields it actually wrote** so callers
+ * can tell a real re-drive from a no-op (shape-drift) one.
+ */
+export declare const __registerStoreRestore: (name: string, restore: (state: Record<string, unknown>) => number) => void;
+/**
+ * Internal/diagnostics tier (Runtime §3) — drive a live store back to a past
+ * `state` (Devtools time-travel re-drive). Looks up the registered restore
+ * closure; when present, fires it (writes the matching state fields + notifies)
+ * and returns the **number of fields written** — 0 when no field in `state`
+ * matched a declared store `state` (e.g. a post-HMR shape drift), so the caller's
+ * "⟲ live" signal can't claim a no-op store moved. Returns 0 when no closure is
+ * registered (never instantiated / torn down) — a view-only degrade, never a throw.
+ */
+export declare const replayStoreState: (name: string, state: Record<string, unknown>) => number;
+declare class StoreRegistryImpl {
+    private instances;
+    private factories;
+    private kinds;
+    private preservedFields;
+    private preserveWarned;
+    private warmers;
+    private subtreePaths;
+    /**
+     * Register a binding. Export / session stores instantiate immediately so a
+     * bare `use storeX` anywhere in the tree resolves. Route stores hold their
+     * factory until the router calls `instantiate(name, { inputs })` on enter.
+     */
+    register: (binding: StoreBinding) => void;
+    /**
+     * Instantiate a route store with the inputs the router mapped from URL
+     * params/query. Idempotent within a single route lifetime — re-entering
+     * the same route disposes the previous instance first (router contract).
+     */
+    instantiate: (name: string, opts?: {
+        inputs?: Record<string, unknown>;
+        preservedKey?: PreservedKey;
+    }) => void;
+    /**
+     * Persist a route store's `preserved state` fields to `sessionStorage` under
+     * the route-entry key (Store §6 / Router §8.4). Called by the route lifecycle
+     * immediately before `dispose` on exit. No-op for stores with no preserved
+     * fields or no live instance. Quota / serialization failures are swallowed
+     * with one `console.warn` per store per session.
+     */
+    savePreservedState: (name: string, key: PreservedKey) => void;
+    /**
+     * Remove a live instance but keep its factory so the next route enter can
+     * rebuild it. Export / session stores live for the app lifetime and are
+     * never disposed by the router.
+     *
+     * Wave 3 §2b — for stores declared `route store ... for subtree "/path"`,
+     * pass the incoming route's pathname in `opts.nextPathname`. The dispose
+     * is SKIPPED when the destination is still inside the subtree (the next
+     * page's `instantiate` becomes a no-op too, so the same instance flows
+     * through the transition). Non-subtree stores ignore the option.
+     */
+    dispose: (name: string, opts?: {
+        nextPathname?: string | null;
+    }) => void;
+    /**
+     * Look up an instance by name. Throws if the store hasn't been instantiated
+     * — either configureStores hasn't run, or it's a route store whose route
+     * isn't active.
+     */
+    get: (name: string) => StoreInstance;
+    /** True if a live instance exists. Used by tests + router wiring. */
+    has: (name: string) => boolean;
+    /**
+     * Internal tier (Runtime §1) — enumerate every registered binding for
+     * diagnostics (the Devtools spec §5 Stores tab). Read-only snapshots;
+     * never part of the public contract.
+     */
+    __list: () => ReadonlyArray<{
+        name: string;
+        kind: StoreBindingKind;
+        instantiated: boolean;
+        preservedFields: readonly string[];
+        subtreePath?: string;
+    }>;
+    /**
+     * Resource v1 §8.2 — invoke a route store's compiler-emitted `warm(inputs,
+     * signal)` companion if present. Pre-fills the resource cache so the
+     * consumer mount that follows hits a fresh entry (Stage E hookup with
+     * `PrefetchRuntime`). Stores without resources omit the companion; this
+     * is a silent no-op. Best-effort: the returned promise resolves even on
+     * warmer failure (the warmer itself swallows; see `warmResource` in
+     * `@reactra/resource`).
+     */
+    warm: (name: string, inputs: Record<string, unknown> | undefined, signal: AbortSignal) => Promise<void>;
+    /**
+     * HMR hot-replace a binding (Compiler §5.3). Compiler-emitted
+     * `import.meta.hot.accept(...)` blocks in store-bearing files call this
+     * after the module re-evaluates so the new factory takes effect without
+     * a full page reload.
+     *
+     * Semantics:
+     * - "export" / "session" — build a fresh instance from the new factory
+     *   and notify any old subscribers, so React re-renders consumers and
+     *   their next `useReactraStore` read picks up the new instance from the
+     *   registry. **State is intentionally lost** (new factory = fresh
+     *   closure vars). Trade-off: the edited action body actually runs.
+     * - "route" — dispose the live instance; the router re-instantiates with
+     *   inputs on the next route enter, which is the natural picking-up
+     *   point for the new factory.
+     *
+     * Idempotent on a name that wasn't registered (treated as a fresh
+     * register) — this happens if the HMR fires before configureStores ran,
+     * which shouldn't occur in practice but isn't worth crashing over.
+     */
+    replace: (binding: StoreBinding) => void;
+    /**
+     * Day 27 / `#5c-followup`: reconcile the registry against a new
+     * `STORES` array (typically the freshly-evaluated `newMod.STORES`
+     * from a HMR-accept callback on the generated route manifest).
+     *
+     * Semantics:
+     * - **Newcomers** (in `newStores`, not in the registry) → `register`.
+     * - **Departures** (in the registry, not in `newStores`) → drop
+     *   factory + instance + kind. Subscribers that hold a stale
+     *   instance reference keep that reference until React re-renders;
+     *   their next `useReactraStore(name)` throws "store not active",
+     *   which is the right signal — the user removed the store, so
+     *   consumers should be next to go.
+     * - **Existing** (in both) → `replace` (so action-body edits to a
+     *   re-emitted store take effect via the existing replace path).
+     *
+     * This is the manifest-level companion to per-file HMR (Day 16 /
+     * `#11`'s `import.meta.hot.accept` block emitted alongside store
+     * containers). The per-file path handles edits to a stable set of
+     * stores; this path handles add/remove of WHOLE store FILES.
+     */
+    applyDelta: (newStores: readonly StoreBinding[]) => void;
+}
+/**
+ * The process-wide store registry singleton. The compiler emits imports of
+ * this and the `useReactraStore` hook below; user code typically doesn't
+ * touch it directly except through `configureStores`.
+ */
+export declare const StoreRegistry: StoreRegistryImpl;
+/**
+ * Internal tier (Runtime §1) — registered-binding enumeration for
+ * diagnostics. Consumed by `@reactra/devtools` (Devtools spec §5).
+ */
+export declare const __listStoreBindings: () => ReadonlyArray<{
+    name: string;
+    kind: StoreBindingKind;
+    instantiated: boolean;
+    preservedFields: readonly string[];
+    subtreePath?: string;
+}>;
+/**
+ * Bootstrap call — invoked from `src/main.tsx` per Runtime v0 §5. Registers
+ * every store binding the app cares about. Order matters: `configureStores`
+ * must precede `configureRouter`.
+ */
+export declare const configureStores: (opts: {
+    stores: StoreBinding[];
+}) => void;
+/**
+ * React hook used by compiler-emitted `use storeX` bindings. Reads the live
+ * snapshot via `useSyncExternalStore`, so the component re-renders when the
+ * store calls `notify()`.
+ *
+ * The compiler destructures the returned object into the bare names the user
+ * wrote (state field, derived, action) — see Compiler v2 §7.3 / Store v4.1 §7.3.
+ *
+ * MVP simplification: snapshot is whole-store; per-field selection (Store
+ * §7.3 Selector Optimization) is a v1 improvement.
+ */
+export declare const useReactraStore: <T extends Record<string, unknown> = Record<string, unknown>>(name: string) => T;
+/**
+ * A2 (Store §7.3 Selector Optimization) — per-FIELD store subscription. Backs
+ * the compiler-emitted field-selected binding `inject store X { a, b }`: the
+ * component re-renders ONLY when one of the selected SOURCE fields changes, not
+ * on every store write.
+ *
+ * The store's `notify()` still fans out to every listener (subscription is
+ * unchanged — C1/C4); the per-field bail-out happens in React via the
+ * `selector` + `isEqual` pair of `useSyncExternalStoreWithSelector`. A write to
+ * an UNselected field re-runs the selector but produces a selection that is
+ * shallow-equal to the previous one, so React skips the re-render.
+ *
+ * `fields` are the store's SOURCE keys (the names on the store surface), NOT the
+ * renamed locals — the compiler keeps the destructure rename in the emitted
+ * code; only the projected source keys flow here (Compiler §7.3 C3).
+ *
+ * The `K extends keyof T = keyof T` generic key-checks `fields` against the
+ * surface — a hand-caller typo (`["staus"]`) is a compile error either way,
+ * because `K` (whether explicit or defaulted to `keyof T`) constrains the array.
+ * Supplying `K` explicitly (`<T, "a" | "b">`) narrows the return to exactly the
+ * selected keys. The `= keyof T` default is load-bearing: the compiler emits a
+ * SINGLE type arg (`useReactraStoreFields<X>("X", ["a","b"])`), and TS requires
+ * every non-defaulted type param when any is given — the default lets that
+ * one-arg emitted form compile (it yields `Pick<T, keyof T>` = `T`, the pre-A2
+ * whole-surface type; the destructure only names selected fields, so this is
+ * harmless). Type-only — emission is byte-identical.
+ *
+ * **Reassignment invariant (Store §7.3):** the per-field bail-out compares each
+ * selected field by `Object.is`, so reactive state must be updated by
+ * REASSIGNMENT (`items = [...items, x]`), not in-place mutation
+ * (`items.push(x)`). An in-place mutation of a selected object/array field keeps
+ * the same reference → `isEqual` returns true → no re-render. (Whole-store /
+ * namespace bindings are unaffected — they re-render on any `notify()`.) This
+ * matches the framework's reassignment-based reactive model.
+ *
+ * **Version-cache invariant:** this relies on `createStoreInstance`'s
+ * version-cache — `getSnapshot` returns the SAME object reference until
+ * `notify()` bumps the version. Every state-changing path MUST call `notify()`
+ * (it does today, via every emitted setter); a write that skips it leaves the
+ * cached snapshot in place, the selector never re-runs, and the consumer never
+ * re-renders.
+ *
+ * @param name   registered store name
+ * @param fields source-key names to select + subscribe to (re-render gate)
+ * @returns an object with exactly the selected source keys
+ */
+export declare const useReactraStoreFields: <T extends Record<string, unknown>, K extends keyof T = keyof T>(name: string, fields: readonly K[]) => Pick<T, K>;
+/**
+ * Compiler-emitted factories call this to build a `StoreInstance`. The
+ * `build` callback receives a `notify` function the factory must call after
+ * every state mutation. The callback returns the snapshot composer — a fn
+ * that produces the current snapshot object on demand. The instance handles
+ * snapshot caching + listener fan-out.
+ *
+ * Shape used by emitted code (see Pass 9 codegen):
+ *
+ *   // export store — no inputs
+ *   createStoreInstance((notify) => {
+ *     let count = 0
+ *     const increment = () => { count = count + 1; notify() }
+ *     return () => ({ count, increment })   // snapshot composer
+ *   })
+ *
+ *   // route store — inputs come from argumented `use storeX(param a, query b)`
+ *   //                via StoreRegistry.instantiate
+ *   (inputs) => createStoreInstance((notify) => {
+ *     const { customerId, returnTo } = inputs ?? {}
+ *     ...
+ *   })
+ */
+export declare const createStoreInstance: <T extends Record<string, unknown>>(build: (notify: () => void) => () => T) => StoreInstance<T>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/index.js

@@ -0,0 +1,570 @@
+// @reactra/store — Store factories + StoreRegistry (Phase 1 MVP)
+//
+// Owner: reactra-store-spec.md (Spec 3.1 / Discussion v4.1)
+//
+// Phase 1 MVP surface — what's shipped today:
+//   StoreRegistry: register / instantiate / dispose / get / has
+//   configureStores({ stores })
+//   useReactraStore(name) — React hook backed by useSyncExternalStore
+//   createStoreInstance — helper consumed by compiler-emitted factories
+//
+// Day 10a addition — route-store lifecycle:
+//   StoreBinding.kind = "export" | "session" | "route" so the registry
+//   knows which factories to eagerly instantiate at configureStores time
+//   (export, session) vs which to defer until the router calls
+//   `instantiate(name, { inputs })` (route).
+//
+// Day 16 addition — HMR replace:
+//   StoreRegistry.replace(binding) — invoked from compiler-emitted
+//   `import.meta.hot.accept(...)` blocks in store-bearing files. Swaps
+//   the factory; for export/session also rebuilds the instance and
+//   notifies old subscribers so consumers re-render against the new
+//   instance. State is intentionally lost (new factory = fresh closure
+//   vars); the trade-off is that the action body edit actually takes
+//   effect. See Compiler §5.3 (HMR Boundary Per File).
+//
+// Preserved state (Store §6) — SHIPPED:
+//   StoreRegistry.savePreservedState(name, key) persists `preserved state`
+//   fields to sessionStorage on route exit; instantiate(name, { preservedKey })
+//   reads them back into the factory's `restored` arg on the next enter.
+//
+// Stage E (Resource v1 §8) — SHIPPED:
+//   StoreBinding.warm? + StoreRegistry.warm(name, inputs, signal) — prefetch
+//   resource warming. The runtime contract is live; the compiler-emitted
+//   warm(inputs, signal) companion (which calls warmResource per-resource
+//   from @reactra/resource) lands in a follow-up compiler stage. Hand-written
+//   bindings that set `warm` work today.
+//
+// Phase 1 deferred:
+//   per-field subscription (today: whole-store notification on any change)
+//   middleware (interceptAction / stateChanged / afterAction)
+//   resources / effects / mount / cleanup inside store bodies
+import { useCallback, useMemo, useSyncExternalStore } from "react";
+// A2 (framework-review §A2 / Store §7.3): per-field store subscription. The shim
+// import is Node-portable (no Bun API) and ships with React's own
+// use-sync-external-store package. The selector + equality gate the RE-RENDER;
+// the underlying `subscribe` is unchanged (notify() still fans to all listeners).
+import { useSyncExternalStoreWithSelector } from "use-sync-external-store/shim/with-selector";
+/** `sessionStorage` key: `reactra:preserved:<name>:<pathname>:<params>|<query>` (Store §6.4). */
+/**
+ * Wave 3 §2b — true when `pathname` is inside the subtree rooted at
+ * `subtreePath`. Path-component atomic — `/checkout` matches `/checkout`
+ * and `/checkout/cart`, but NOT `/checkout-summary`. Trailing slashes on
+ * `subtreePath` are normalised away.
+ */
+const isInsideSubtree = (pathname, subtreePath) => {
+    const stripped = subtreePath.endsWith("/") ? subtreePath.slice(0, -1) : subtreePath;
+    if (pathname === stripped)
+        return true;
+    return pathname.startsWith(stripped + "/");
+};
+const preservedStorageKey = (name, k) => `reactra:preserved:${name}:${k.pathname}:${JSON.stringify(k.params)}|${JSON.stringify(k.query)}`;
+/** Read + parse a preserved slot; `undefined` if absent / unavailable / malformed. */
+const readPreserved = (key) => {
+    if (typeof sessionStorage === "undefined")
+        return undefined;
+    try {
+        const raw = sessionStorage.getItem(key);
+        if (raw == null)
+            return undefined;
+        const parsed = JSON.parse(raw);
+        return parsed != null && typeof parsed === "object"
+            ? parsed
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+/** Write a serialized preserved slot. Throws on quota — `savePreservedState` swallows. */
+const writePreserved = (key, json) => {
+    if (typeof sessionStorage === "undefined")
+        return;
+    sessionStorage.setItem(key, json);
+};
+/**
+ * Module-private name-keyed registry of compiler-emitted store restore
+ * closures (Store §6 / Devtools time-travel). Pass 9 emits, inside each store
+ * factory, a call to `__registerStoreRestore(name, restore)` where `restore`
+ * writes the `state` fields of a `next` map into the factory's closure `let`s
+ * and calls the factory's `notify`. Last-wins per name (a re-instantiated
+ * factory overwrites the stale closure). Cleared on instance teardown so a
+ * `replayStoreState` against a torn-down store degrades to a view-only no-op.
+ *
+ * This is a plain module-level map — `@reactra/store` takes NO dependency edge
+ * toward devtools/replay (architect condition C2).
+ */
+const storeRestores = new Map();
+/**
+ * Internal/diagnostics tier (Runtime §3) — register a store's restore closure.
+ * Compiler-emitted (Pass 9); last-wins per name. Mirrors `__listStoreBindings`.
+ * The closure returns the **count of state fields it actually wrote** so callers
+ * can tell a real re-drive from a no-op (shape-drift) one.
+ */
+export const __registerStoreRestore = (name, restore) => {
+    storeRestores.set(name, restore);
+};
+/**
+ * Internal/diagnostics tier (Runtime §3) — drive a live store back to a past
+ * `state` (Devtools time-travel re-drive). Looks up the registered restore
+ * closure; when present, fires it (writes the matching state fields + notifies)
+ * and returns the **number of fields written** — 0 when no field in `state`
+ * matched a declared store `state` (e.g. a post-HMR shape drift), so the caller's
+ * "⟲ live" signal can't claim a no-op store moved. Returns 0 when no closure is
+ * registered (never instantiated / torn down) — a view-only degrade, never a throw.
+ */
+export const replayStoreState = (name, state) => {
+    const restore = storeRestores.get(name);
+    if (restore === undefined)
+        return 0;
+    return restore(state);
+};
+class StoreRegistryImpl {
+    instances = new Map();
+    factories = new Map();
+    kinds = new Map();
+    // `preserved state` field names per store (Store §6). Empty/absent → the
+    // save/restore paths are no-ops for that store.
+    preservedFields = new Map();
+    // One save-failure warning per store per session (quota / serialization).
+    preserveWarned = new Set();
+    // Stage E (Resource v1 §8) — per-store `warm(inputs, signal)` companions,
+    // populated by `register`/`replace`/`applyDelta` from the binding. Stores
+    // without resources have no entry; `warm()` no-ops in that case.
+    warmers = new Map();
+    // Wave 3 §2b — `for subtree "/path"` subtree paths per store. Drives the
+    // skip-instantiate + skip-dispose logic so a single instance survives
+    // across every page whose pathname starts with the subtree path. No
+    // entry → store is a regular per-route store (existing behaviour).
+    subtreePaths = new Map();
+    /**
+     * Register a binding. Export / session stores instantiate immediately so a
+     * bare `use storeX` anywhere in the tree resolves. Route stores hold their
+     * factory until the router calls `instantiate(name, { inputs })` on enter.
+     */
+    register = (binding) => {
+        if (this.factories.has(binding.name)) {
+            throw new Error(`[reactra:store] S001: store "${binding.name}" is already registered`);
+        }
+        this.factories.set(binding.name, binding.factory);
+        this.kinds.set(binding.name, binding.kind);
+        if (binding.preservedFields && binding.preservedFields.length > 0) {
+            this.preservedFields.set(binding.name, binding.preservedFields);
+        }
+        if (binding.warm !== undefined) {
+            this.warmers.set(binding.name, binding.warm);
+        }
+        if (binding.subtreePath !== undefined && binding.subtreePath.length > 0) {
+            this.subtreePaths.set(binding.name, binding.subtreePath);
+        }
+        if (binding.kind === "export" || binding.kind === "session") {
+            this.instances.set(binding.name, binding.factory());
+        }
+    };
+    /**
+     * Instantiate a route store with the inputs the router mapped from URL
+     * params/query. Idempotent within a single route lifetime — re-entering
+     * the same route disposes the previous instance first (router contract).
+     */
+    instantiate = (name, opts = {}) => {
+        const factory = this.factories.get(name);
+        if (!factory) {
+            throw new Error(`[reactra:store] cannot instantiate "${name}" — no factory registered`);
+        }
+        // Wave 3 §2b — for subtree stores, REUSE the existing instance when one
+        // is already alive (the previous page in the subtree built it; the new
+        // page joins the same lifecycle). Inputs from the new page are
+        // ignored — the entry route's inputs are what defined the store, per
+        // Router §4.6 "argumented form passes inputs at subtree entry; bare
+        // form everywhere else in the subtree". Non-subtree stores keep the
+        // existing always-rebuild behaviour.
+        if (this.subtreePaths.has(name) && this.instances.has(name)) {
+            return;
+        }
+        // Preserved-state restore (Store §6): if this route store opted into
+        // `preserved state` AND the router passed the entry key, read the persisted
+        // values back and hand them to the factory, which overwrites the matching
+        // `state` fields before the snapshot composer runs — so the restored values
+        // are visible on first render (before React subscribes). No-op for stores
+        // with no preserved fields or when the entry has nothing stored.
+        const fields = this.preservedFields.get(name);
+        const restored = fields && fields.length > 0 && opts.preservedKey
+            ? readPreserved(preservedStorageKey(name, opts.preservedKey))
+            : undefined;
+        this.instances.set(name, factory(opts.inputs, restored));
+    };
+    /**
+     * Persist a route store's `preserved state` fields to `sessionStorage` under
+     * the route-entry key (Store §6 / Router §8.4). Called by the route lifecycle
+     * immediately before `dispose` on exit. No-op for stores with no preserved
+     * fields or no live instance. Quota / serialization failures are swallowed
+     * with one `console.warn` per store per session.
+     */
+    savePreservedState = (name, key) => {
+        const fields = this.preservedFields.get(name);
+        if (!fields || fields.length === 0)
+            return;
+        const inst = this.instances.get(name);
+        if (!inst)
+            return;
+        try {
+            const snap = inst.getSnapshot();
+            const out = {};
+            for (const f of fields)
+                out[f] = snap[f];
+            writePreserved(preservedStorageKey(name, key), JSON.stringify(out));
+        }
+        catch (err) {
+            if (!this.preserveWarned.has(name)) {
+                this.preserveWarned.add(name);
+                console.warn(`[reactra:store] preserved-state save failed for "${name}"`, err);
+            }
+        }
+    };
+    /**
+     * Remove a live instance but keep its factory so the next route enter can
+     * rebuild it. Export / session stores live for the app lifetime and are
+     * never disposed by the router.
+     *
+     * Wave 3 §2b — for stores declared `route store ... for subtree "/path"`,
+     * pass the incoming route's pathname in `opts.nextPathname`. The dispose
+     * is SKIPPED when the destination is still inside the subtree (the next
+     * page's `instantiate` becomes a no-op too, so the same instance flows
+     * through the transition). Non-subtree stores ignore the option.
+     */
+    dispose = (name, opts = {}) => {
+        const subtreePath = this.subtreePaths.get(name);
+        if (subtreePath !== undefined &&
+            typeof opts.nextPathname === "string" &&
+            isInsideSubtree(opts.nextPathname, subtreePath)) {
+            // Still inside the subtree — keep the instance alive for the next page.
+            return;
+        }
+        this.instances.delete(name);
+        // C7: the torn-down instance's restore closure points at dead closure vars;
+        // drop it so a stale `replayStoreState(name, ...)` degrades to a view-only
+        // no-op (returns 0) instead of writing into the old closure.
+        storeRestores.delete(name);
+    };
+    /**
+     * Look up an instance by name. Throws if the store hasn't been instantiated
+     * — either configureStores hasn't run, or it's a route store whose route
+     * isn't active.
+     */
+    get = (name) => {
+        const inst = this.instances.get(name);
+        if (!inst) {
+            throw new Error(`[reactra:store] store "${name}" is not active — either configureStores() didn't register it, or it's a route store whose route isn't entered`);
+        }
+        return inst;
+    };
+    /** True if a live instance exists. Used by tests + router wiring. */
+    has = (name) => this.instances.has(name);
+    /**
+     * Internal tier (Runtime §1) — enumerate every registered binding for
+     * diagnostics (the Devtools spec §5 Stores tab). Read-only snapshots;
+     * never part of the public contract.
+     */
+    __list = () => [...this.factories.keys()].map((name) => ({
+        name,
+        // kinds is populated in lockstep with factories by register/replace.
+        kind: this.kinds.get(name),
+        instantiated: this.instances.has(name),
+        preservedFields: this.preservedFields.get(name) ?? [],
+        ...(this.subtreePaths.has(name) ? { subtreePath: this.subtreePaths.get(name) } : {}),
+    }));
+    /**
+     * Resource v1 §8.2 — invoke a route store's compiler-emitted `warm(inputs,
+     * signal)` companion if present. Pre-fills the resource cache so the
+     * consumer mount that follows hits a fresh entry (Stage E hookup with
+     * `PrefetchRuntime`). Stores without resources omit the companion; this
+     * is a silent no-op. Best-effort: the returned promise resolves even on
+     * warmer failure (the warmer itself swallows; see `warmResource` in
+     * `@reactra/resource`).
+     */
+    warm = (name, inputs, signal) => {
+        const w = this.warmers.get(name);
+        if (w === undefined)
+            return Promise.resolve();
+        return w(inputs, signal).catch(() => {
+            // Defensive — the warmer itself is documented best-effort, but a
+            // hand-written binding that rejects must not break the route prefetch.
+        });
+    };
+    /**
+     * HMR hot-replace a binding (Compiler §5.3). Compiler-emitted
+     * `import.meta.hot.accept(...)` blocks in store-bearing files call this
+     * after the module re-evaluates so the new factory takes effect without
+     * a full page reload.
+     *
+     * Semantics:
+     * - "export" / "session" — build a fresh instance from the new factory
+     *   and notify any old subscribers, so React re-renders consumers and
+     *   their next `useReactraStore` read picks up the new instance from the
+     *   registry. **State is intentionally lost** (new factory = fresh
+     *   closure vars). Trade-off: the edited action body actually runs.
+     * - "route" — dispose the live instance; the router re-instantiates with
+     *   inputs on the next route enter, which is the natural picking-up
+     *   point for the new factory.
+     *
+     * Idempotent on a name that wasn't registered (treated as a fresh
+     * register) — this happens if the HMR fires before configureStores ran,
+     * which shouldn't occur in practice but isn't worth crashing over.
+     */
+    replace = (binding) => {
+        const oldInst = this.instances.get(binding.name);
+        // C7 (HMR): drop the stale restore closure before the new factory runs.
+        // For export/session the rebuild below re-emits `__registerStoreRestore`
+        // (last-wins); clearing first guarantees a factory edited to drop all
+        // `state` fields leaves no stale closure pointing at dead vars. For route
+        // stores the live instance is kept, but its closure was rebuilt on the
+        // last instantiate — a mid-scrub HMR tolerating the swap drops travel
+        // state with no throw (the next instantiate re-registers).
+        storeRestores.delete(binding.name);
+        this.factories.set(binding.name, binding.factory);
+        this.kinds.set(binding.name, binding.kind);
+        if (binding.preservedFields && binding.preservedFields.length > 0) {
+            this.preservedFields.set(binding.name, binding.preservedFields);
+        }
+        else {
+            this.preservedFields.delete(binding.name);
+        }
+        if (binding.warm !== undefined) {
+            this.warmers.set(binding.name, binding.warm);
+        }
+        else {
+            this.warmers.delete(binding.name);
+        }
+        if (binding.kind === "route") {
+            // Day 18 / `#18b`: keep the live instance. The router naturally
+            // re-instantiates on the next route enter, which is the right
+            // pickup point for the new factory. Disposing here would throw
+            // "store not active" in any mounted consumer the moment we
+            // achieve HMR for a file with a live route store.
+            return;
+        }
+        this.instances.set(binding.name, binding.factory());
+        if (oldInst)
+            oldInst.notify();
+    };
+    /**
+     * Day 27 / `#5c-followup`: reconcile the registry against a new
+     * `STORES` array (typically the freshly-evaluated `newMod.STORES`
+     * from a HMR-accept callback on the generated route manifest).
+     *
+     * Semantics:
+     * - **Newcomers** (in `newStores`, not in the registry) → `register`.
+     * - **Departures** (in the registry, not in `newStores`) → drop
+     *   factory + instance + kind. Subscribers that hold a stale
+     *   instance reference keep that reference until React re-renders;
+     *   their next `useReactraStore(name)` throws "store not active",
+     *   which is the right signal — the user removed the store, so
+     *   consumers should be next to go.
+     * - **Existing** (in both) → `replace` (so action-body edits to a
+     *   re-emitted store take effect via the existing replace path).
+     *
+     * This is the manifest-level companion to per-file HMR (Day 16 /
+     * `#11`'s `import.meta.hot.accept` block emitted alongside store
+     * containers). The per-file path handles edits to a stable set of
+     * stores; this path handles add/remove of WHOLE store FILES.
+     */
+    applyDelta = (newStores) => {
+        const newNames = new Set(newStores.map((s) => s.name));
+        // Departures first — drop the old factories+instances before we
+        // potentially register a same-named newcomer (defensive; the loops
+        // below shouldn't overlap on names but the order keeps it sane).
+        for (const name of [...this.factories.keys()]) {
+            if (!newNames.has(name)) {
+                this.instances.delete(name);
+                this.factories.delete(name);
+                this.kinds.delete(name);
+                this.preservedFields.delete(name);
+                this.warmers.delete(name);
+                // C7: a departed store's restore closure must not survive the delta.
+                storeRestores.delete(name);
+            }
+        }
+        // Newcomers + existing — replace handles both (idempotent on
+        // an unknown name; see its own docstring).
+        for (const binding of newStores) {
+            if (this.factories.has(binding.name)) {
+                this.replace(binding);
+            }
+            else {
+                this.register(binding);
+            }
+        }
+    };
+}
+/**
+ * The process-wide store registry singleton. The compiler emits imports of
+ * this and the `useReactraStore` hook below; user code typically doesn't
+ * touch it directly except through `configureStores`.
+ */
+export const StoreRegistry = new StoreRegistryImpl();
+/**
+ * Internal tier (Runtime §1) — registered-binding enumeration for
+ * diagnostics. Consumed by `@reactra/devtools` (Devtools spec §5).
+ */
+export const __listStoreBindings = StoreRegistry.__list;
+/**
+ * Bootstrap call — invoked from `src/main.tsx` per Runtime v0 §5. Registers
+ * every store binding the app cares about. Order matters: `configureStores`
+ * must precede `configureRouter`.
+ */
+export const configureStores = (opts) => {
+    for (const binding of opts.stores)
+        StoreRegistry.register(binding);
+};
+/**
+ * React hook used by compiler-emitted `use storeX` bindings. Reads the live
+ * snapshot via `useSyncExternalStore`, so the component re-renders when the
+ * store calls `notify()`.
+ *
+ * The compiler destructures the returned object into the bare names the user
+ * wrote (state field, derived, action) — see Compiler v2 §7.3 / Store v4.1 §7.3.
+ *
+ * MVP simplification: snapshot is whole-store; per-field selection (Store
+ * §7.3 Selector Optimization) is a v1 improvement.
+ */
+export const useReactraStore = (name) => {
+    const inst = StoreRegistry.get(name);
+    // useCallback so React sees stable subscribe/getSnapshot references and
+    // doesn't tear them down between renders.
+    const subscribe = useCallback((onChange) => inst.subscribe(onChange), [inst]);
+    const getSnapshot = useCallback(() => inst.getSnapshot(), [inst]);
+    return useSyncExternalStore(subscribe, getSnapshot);
+};
+/**
+ * A2 (Store §7.3 Selector Optimization) — per-FIELD store subscription. Backs
+ * the compiler-emitted field-selected binding `inject store X { a, b }`: the
+ * component re-renders ONLY when one of the selected SOURCE fields changes, not
+ * on every store write.
+ *
+ * The store's `notify()` still fans out to every listener (subscription is
+ * unchanged — C1/C4); the per-field bail-out happens in React via the
+ * `selector` + `isEqual` pair of `useSyncExternalStoreWithSelector`. A write to
+ * an UNselected field re-runs the selector but produces a selection that is
+ * shallow-equal to the previous one, so React skips the re-render.
+ *
+ * `fields` are the store's SOURCE keys (the names on the store surface), NOT the
+ * renamed locals — the compiler keeps the destructure rename in the emitted
+ * code; only the projected source keys flow here (Compiler §7.3 C3).
+ *
+ * The `K extends keyof T = keyof T` generic key-checks `fields` against the
+ * surface — a hand-caller typo (`["staus"]`) is a compile error either way,
+ * because `K` (whether explicit or defaulted to `keyof T`) constrains the array.
+ * Supplying `K` explicitly (`<T, "a" | "b">`) narrows the return to exactly the
+ * selected keys. The `= keyof T` default is load-bearing: the compiler emits a
+ * SINGLE type arg (`useReactraStoreFields<X>("X", ["a","b"])`), and TS requires
+ * every non-defaulted type param when any is given — the default lets that
+ * one-arg emitted form compile (it yields `Pick<T, keyof T>` = `T`, the pre-A2
+ * whole-surface type; the destructure only names selected fields, so this is
+ * harmless). Type-only — emission is byte-identical.
+ *
+ * **Reassignment invariant (Store §7.3):** the per-field bail-out compares each
+ * selected field by `Object.is`, so reactive state must be updated by
+ * REASSIGNMENT (`items = [...items, x]`), not in-place mutation
+ * (`items.push(x)`). An in-place mutation of a selected object/array field keeps
+ * the same reference → `isEqual` returns true → no re-render. (Whole-store /
+ * namespace bindings are unaffected — they re-render on any `notify()`.) This
+ * matches the framework's reassignment-based reactive model.
+ *
+ * **Version-cache invariant:** this relies on `createStoreInstance`'s
+ * version-cache — `getSnapshot` returns the SAME object reference until
+ * `notify()` bumps the version. Every state-changing path MUST call `notify()`
+ * (it does today, via every emitted setter); a write that skips it leaves the
+ * cached snapshot in place, the selector never re-runs, and the consumer never
+ * re-renders.
+ *
+ * @param name   registered store name
+ * @param fields source-key names to select + subscribe to (re-render gate)
+ * @returns an object with exactly the selected source keys
+ */
+export const useReactraStoreFields = (name, fields) => {
+    const inst = StoreRegistry.get(name);
+    const subscribe = useCallback((onChange) => inst.subscribe(onChange), [inst]);
+    const getSnapshot = useCallback(() => inst.getSnapshot(), [inst]);
+    // Stable selector + equality keyed on the field list. The selector projects
+    // the selected source keys; `isEqual` is a shallow Object.is comparison over
+    // exactly those keys — the per-field bail-out. We do NOT allocate the selected
+    // object outside the selector (the selector's own result is what
+    // with-selector memoizes against the previous selection via `isEqual`).
+    const key = fields.join(",");
+    const { selector, isEqual } = useMemo(() => {
+        const sel = (snap) => {
+            const out = {};
+            for (const f of fields)
+                out[f] = snap[f];
+            return out;
+        };
+        const eq = (a, b) => {
+            for (const f of fields) {
+                if (!Object.is(a[f], b[f])) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        return { selector: sel, isEqual: eq };
+        // `key` is the stable identity of `fields`; recompute only when it changes.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [key]);
+    return useSyncExternalStoreWithSelector(subscribe, getSnapshot, 
+    // getServerSnapshot: same source as the client snapshot. Correct for CSR;
+    // when SSR lands this must return a request-scoped snapshot or hydration
+    // will mismatch (ref specs/adr/0001-ssr-scoping.md — singleton registries
+    // are the client-only boundary).
+    getSnapshot, selector, isEqual);
+};
+/**
+ * Compiler-emitted factories call this to build a `StoreInstance`. The
+ * `build` callback receives a `notify` function the factory must call after
+ * every state mutation. The callback returns the snapshot composer — a fn
+ * that produces the current snapshot object on demand. The instance handles
+ * snapshot caching + listener fan-out.
+ *
+ * Shape used by emitted code (see Pass 9 codegen):
+ *
+ *   // export store — no inputs
+ *   createStoreInstance((notify) => {
+ *     let count = 0
+ *     const increment = () => { count = count + 1; notify() }
+ *     return () => ({ count, increment })   // snapshot composer
+ *   })
+ *
+ *   // route store — inputs come from argumented `use storeX(param a, query b)`
+ *   //                via StoreRegistry.instantiate
+ *   (inputs) => createStoreInstance((notify) => {
+ *     const { customerId, returnTo } = inputs ?? {}
+ *     ...
+ *   })
+ */
+export const createStoreInstance = (build) => {
+    const listeners = new Set();
+    let version = 0;
+    let cachedSnapshot = null;
+    let cachedVersion = -1;
+    const notify = () => {
+        version++;
+        cachedSnapshot = null;
+        for (const l of listeners)
+            l();
+    };
+    const compose = build(notify);
+    return {
+        subscribe: (onChange) => {
+            listeners.add(onChange);
+            return () => listeners.delete(onChange);
+        },
+        getSnapshot: () => {
+            if (cachedVersion !== version || cachedSnapshot === null) {
+                cachedSnapshot = compose();
+                cachedVersion = version;
+            }
+            return cachedSnapshot;
+        },
+        notify,
+    };
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@reactra/store",
+  "version": "0.1.0-alpha.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "use-sync-external-store": "^1.5.0"
+  },
+  "peerDependencies": {
+    "react": "^19.2.0"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha",
+    "provenance": false
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/akhilshastri/reactra.git",
+    "directory": "packages/store"
+  },
+  "homepage": "https://reactra-docs.vercel.app",
+  "license": "MIT",
+  "engines": {
+    "node": ">=22.18"
+  },
+  "sideEffects": false,
+  "description": "Reactra store runtime — scoped, fine-grained, per-field-subscription state for Reactra apps."
+}