@kdeveloper/kvark 0.1.1

package/README.md

@@ -0,0 +1,329 @@
+# @kdeveloper/kvark
+
+Atomic state management for React with **explicit dependency graphs**, stale-while-revalidate, and first-class external invalidation.
+
+Inspired by Jotai, but built around a key difference: dependencies are declared upfront rather than inferred at runtime. This makes the data graph statically analysable, enables parallel loading, and allows invalidation from anywhere — WebSocket handlers, SSE streams, timers, Service Workers — without any React hooks.
+
+```
+npm install @kdeveloper/kvark
+# peer dependency: react >=18
+```
+
+## Why Kvark?
+
+|                        | Jotai                            | Kvark                                           |
+| ---------------------- | -------------------------------- | ----------------------------------------------- |
+| Dependency declaration | Implicit (via `get(atom)` calls) | Explicit, via `dependencies` field              |
+| `atom()` signature     | `atom(read, write?)`             | `atom({ get, set?, dependencies? })`            |
+| Async model            | Optional                         | `get`, `set`, `ctx.get` — always `async`        |
+| Parallel loading       | Manual `Promise.all`             | Built-in through `dependencies`                 |
+| Stale-while-revalidate | Re-suspends on revalidation      | Shows stale data; Suspense only on first load   |
+| `atomFamily`           | External (`jotai/utils`)         | Core, with LRU and invalidation                 |
+| External invalidation  | `store.set()`                    | Explicit `store.invalidate()` / `StoreClient`   |
+| TypeScript strictness  | `strict: true` recommended       | `strict: true` + 8 extra flags, `any` forbidden |
+
+## Installation
+
+```bash
+pnpm add @kdeveloper/kvark
+# react >=18 is a peer dependency
+```
+
+## Quick Start
+
+```tsx
+import { atom, createStore } from "@kdeveloper/kvark";
+import { Provider, useAtomValue, useSetAtom } from "@kdeveloper/kvark/react";
+
+// 1. Create atoms
+const userIdAtom = atom({
+  debugLabel: "userId",
+  get: async () => 1,
+  set: async (_ctx, id: number) => id,
+});
+
+const userAtom = atom({
+  debugLabel: "user",
+  dependencies: { userId: userIdAtom },
+  get: async (ctx) => {
+    const id = await ctx.get("userId");
+    const res = await fetch(`/api/users/${id}`, { signal: ctx.signal });
+    return res.json();
+  },
+});
+
+// 2. Create a store
+const store = createStore();
+
+// 3. Wrap your app
+function App() {
+  return (
+    <Provider store={store}>
+      <Suspense fallback="Loading...">
+        <UserCard />
+      </Suspense>
+    </Provider>
+  );
+}
+
+// 4. Use in components
+function UserCard() {
+  const user = useAtomValue(userAtom);
+  return <div>{user.name}</div>;
+}
+```
+
+## Core Concepts
+
+### Atoms
+
+An atom is the smallest unit of state. Its `get` function is always `async`, and dependencies must be declared explicitly.
+
+```ts
+import { atom } from "@kdeveloper/kvark";
+
+// Primitive atom — no dependencies
+const countAtom = atom({
+  debugLabel: "count",
+  get: async () => 0,
+  set: async (_ctx, value: number) => value,
+});
+
+// Derived atom — reads from another atom
+const doubleAtom = atom({
+  debugLabel: "double",
+  dependencies: { count: countAtom },
+  get: async (ctx) => {
+    const n = await ctx.get("count");
+    return n * 2;
+  },
+});
+```
+
+### Parallel loading
+
+Declaring multiple dependencies causes the Store to resolve them in parallel before calling `get`. Inside `get` you control the parallelism explicitly.
+
+```ts
+const dashboardAtom = atom({
+  dependencies: { user: userAtom, settings: settingsAtom },
+  get: async (ctx) => {
+    const [user, settings] = await Promise.all([ctx.get("user"), ctx.get("settings")]);
+    return { user, settings };
+  },
+});
+```
+
+### Stale-while-revalidate
+
+By default (`stalePolicy: 'keep'`), invalidating an atom marks it `stale` while preserving the last value. Components keep rendering the old data without re-suspending. Once revalidation completes the atom becomes `fresh` again.
+
+```
+pending  →  fresh     (first load)
+fresh    →  stale     (invalidated — old value kept)
+stale    →  fresh     (revalidation complete)
+stale    →  error     (revalidation failed — value preserved with 'keep')
+```
+
+Use `{ observe: true }` to access the `isStale` flag in your component:
+
+```tsx
+function UserCard() {
+  const { value: user, isStale, error } = useAtomValue(userAtom, { observe: true });
+
+  return (
+    <div style={{ opacity: isStale ? 0.6 : 1 }}>
+      <p>{user.name}</p>
+      {isStale && <Spinner />}
+      {error != null && <ErrorBanner error={error} />}
+    </div>
+  );
+}
+```
+
+Available `stalePolicy` values:
+
+| Value              | Behaviour                                      |
+| ------------------ | ---------------------------------------------- |
+| `'keep'` (default) | Show stale data, revalidate in background      |
+| `'suspend'`        | Re-throw Promise on revalidation (re-suspends) |
+| `'reset'`          | Clear value and re-suspend immediately         |
+
+### `atomFamily`
+
+Create a family of atoms parametrised by a key. Atoms are cached by param; supports LRU eviction.
+
+```ts
+import { atomFamily } from "@kdeveloper/kvark/family";
+
+const postFamily = atomFamily({
+  debugLabel: "post",
+  cachePolicy: "lru",
+  lruSize: 50,
+  dependencies: (_postId: number) => ({ user: userAtom }),
+  get: (postId) => async (ctx) => {
+    const user = await ctx.get("user");
+    const res = await fetch(`/api/posts/${postId}?userId=${user.id}`, {
+      signal: ctx.signal,
+    });
+    return res.json();
+  },
+});
+
+// Use in a component
+const post = useAtomValue(postFamily(42));
+
+// Invalidate after a mutation
+await api.updatePost(42, data);
+postFamily.invalidate(42);
+
+// Invalidate everything (e.g. on logout)
+postFamily.invalidateAll();
+```
+
+## React Hooks
+
+All hooks must be used inside a `<Provider>`.
+
+### `useAtomValue`
+
+Reads an atom value and subscribes to updates. Suspends on first load.
+
+```tsx
+// Basic — throws if error, suspends if pending
+const user = useAtomValue(userAtom);
+
+// Observed — exposes isStale and error without throwing
+const { value, isStale, error } = useAtomValue(userAtom, { observe: true });
+```
+
+### `useSetAtom`
+
+Returns the setter for a writable atom, without subscribing to the value.
+
+```tsx
+const setCount = useSetAtom(countAtom);
+await setCount(42);
+```
+
+### `useAtom`
+
+Combines `useAtomValue` and `useSetAtom` into a `[value, setter]` tuple.
+
+```tsx
+const [count, setCount] = useAtom(countAtom);
+```
+
+### `useAtomCallback`
+
+Imperative access to the `StoreClient` inside a callback. Does not subscribe.
+
+```tsx
+const readBalance = useAtomCallback(async (client) => {
+  return client.get(balanceAtom);
+});
+
+// Call imperatively, e.g. in an event handler
+const balance = await readBalance();
+```
+
+## External Invalidation
+
+`StoreClient` exposes the store's full capabilities outside of React — useful for WebSocket handlers, SSE streams, polling timers, and Service Workers.
+
+```ts
+import { createStore } from "@kdeveloper/kvark";
+
+const store = createStore();
+const client = store.getClient();
+
+// WebSocket
+const ws = new WebSocket("wss://api.example.com/events");
+ws.addEventListener("message", (event) => {
+  const msg = JSON.parse(event.data);
+  if (msg.type === "post.updated") {
+    postFamily.invalidate(msg.postId);
+  }
+  if (msg.type === "user.updated") {
+    client.invalidate(userAtom);
+  }
+});
+
+// SSE
+const sse = new EventSource("/api/stream");
+sse.addEventListener("prices.updated", () => {
+  client.invalidate(pricesAtom);
+});
+
+// Polling
+setInterval(() => client.invalidate(statusAtom), 30_000);
+
+// Subscribe to state changes outside React
+const unsub = client.subscribe(userAtom, (state) => {
+  if (state.status === "fresh") {
+    analytics.identify(state.value.id);
+  }
+});
+```
+
+### `StoreClient` interface
+
+```ts
+interface StoreClient {
+  get<V>(atom: Atom<V>): Promise<V>;
+  set<V, A extends readonly unknown[]>(atom: WritableAtom<V, A>, ...args: A): Promise<void>;
+  invalidate(atom: Atom<unknown>): void;
+  invalidateMany(atoms: ReadonlyArray<Atom<unknown>>): void;
+  subscribe<V>(atom: Atom<V>, listener: (state: AtomState<V>) => void): () => void;
+}
+```
+
+## Provider and Store Setup
+
+```tsx
+// store.ts
+import { createStore } from "@kdeveloper/kvark";
+export const store = createStore();
+
+// App.tsx
+import { Provider } from "@kdeveloper/kvark/react";
+import { store } from "./store";
+
+export function App() {
+  return (
+    <Provider store={store}>
+      <Router />
+    </Provider>
+  );
+}
+```
+
+## Utility Types
+
+```ts
+import type { AtomValue, AtomArgs, IsWritable } from "@kdeveloper/kvark";
+
+type UserData = AtomValue<typeof userAtom>; // → User
+type PostArgs = AtomArgs<typeof postAtom>; // → [postId: number]
+type Writable = IsWritable<typeof countAtom>; // → true | false
+```
+
+## Package Structure
+
+| Import                     | Contents                                                               |
+| -------------------------- | ---------------------------------------------------------------------- |
+| `@kdeveloper/kvark`        | `atom`, `createStore`, all types                                       |
+| `@kdeveloper/kvark/react`  | `Provider`, `useAtomValue`, `useSetAtom`, `useAtom`, `useAtomCallback` |
+| `@kdeveloper/kvark/family` | `atomFamily`                                                           |
+
+The core (`@kdeveloper/kvark`) has **zero runtime dependencies**. React is a peer dependency only needed when using the `/react` subpath.
+
+## Requirements
+
+- **Node.js** ≥ 20
+- **TypeScript** ≥ 6 (strict mode recommended)
+- **React** ≥ 18 (for `@kdeveloper/kvark/react`)
+
+## License
+
+MIT

package/dist/chunk-6WIZ6MFN.js

@@ -0,0 +1,405 @@
+// src/internal/types.ts
+var CONFIG = /* @__PURE__ */ Symbol("kvark.config");
+var WRITABLE = /* @__PURE__ */ Symbol("kvark.writable");
+var FAMILY_LINK = /* @__PURE__ */ Symbol("kvark.familyLink");
+
+// src/internal/atom.ts
+function atom(config) {
+  const internal = /* @__PURE__ */ Object.create(null);
+  internal.get = config.get;
+  if (config.debugLabel != null) {
+    internal.debugLabel = config.debugLabel;
+  }
+  if (config.dependencies != null) {
+    internal.dependencies = config.dependencies;
+  }
+  if (config.stalePolicy != null) {
+    internal.stalePolicy = config.stalePolicy;
+  }
+  if (config.set != null) {
+    internal.set = config.set;
+  }
+  if (config.set != null) {
+    return {
+      [CONFIG]: internal,
+      [WRITABLE]: [],
+      debugLabel: config.debugLabel
+    };
+  }
+  return {
+    [CONFIG]: internal,
+    debugLabel: config.debugLabel
+  };
+}
+
+// src/internal/family.ts
+function getFamilyLink(target) {
+  return target[FAMILY_LINK];
+}
+function atomFamily(options) {
+  const cachePolicy = options.cachePolicy ?? "keep-all";
+  const lruSize = options.lruSize ?? 100;
+  const cache = /* @__PURE__ */ new Map();
+  const lruOrder = [];
+  const storeCallbacks = /* @__PURE__ */ new Set();
+  const link = {
+    invalidateAtom(target) {
+      for (const cb of storeCallbacks) {
+        cb(target);
+      }
+    },
+    registerStore(cb) {
+      storeCallbacks.add(cb);
+      return () => {
+        storeCallbacks.delete(cb);
+      };
+    }
+  };
+  function attachLink(target) {
+    target[FAMILY_LINK] = link;
+  }
+  function getOrCreate(param) {
+    const cached = cache.get(param);
+    if (cached != null) {
+      if (cachePolicy === "lru") {
+        touchLru(param);
+      }
+      return cached;
+    }
+    const deps = options.dependencies?.(param);
+    const getFn = options.get(param);
+    const setFn = options.set?.(param);
+    const label = options.debugLabel != null ? `${options.debugLabel}(${String(param)})` : void 0;
+    const created = createAtom(label, deps, getFn, setFn);
+    attachLink(created);
+    cache.set(param, created);
+    if (cachePolicy === "lru") {
+      lruOrder.push(param);
+      evictLru();
+    }
+    return created;
+  }
+  function createAtom(label, deps, getFn, setFn) {
+    const base = {
+      get: getFn
+    };
+    if (label != null) {
+      base.debugLabel = label;
+    }
+    if (deps != null) {
+      base.dependencies = deps;
+    }
+    if (options.stalePolicy != null) {
+      base.stalePolicy = options.stalePolicy;
+    }
+    if (setFn != null) {
+      base.set = setFn;
+      return atom(
+        base
+      );
+    }
+    return atom(base);
+  }
+  function touchLru(param) {
+    const idx = lruOrder.indexOf(param);
+    if (idx !== -1) {
+      lruOrder.splice(idx, 1);
+    }
+    lruOrder.push(param);
+  }
+  function evictLru() {
+    while (lruOrder.length > lruSize) {
+      const evicted = lruOrder.shift();
+      if (evicted !== void 0) {
+        cache.delete(evicted);
+      }
+    }
+  }
+  const family = getOrCreate;
+  family.invalidate = (param) => {
+    const cached = cache.get(param);
+    if (cached != null) {
+      link.invalidateAtom(cached);
+    }
+  };
+  family.invalidateAll = () => {
+    for (const cached of cache.values()) {
+      link.invalidateAtom(cached);
+    }
+  };
+  family.remove = (param) => {
+    cache.delete(param);
+    if (cachePolicy === "lru") {
+      const idx = lruOrder.indexOf(param);
+      if (idx !== -1) {
+        lruOrder.splice(idx, 1);
+      }
+    }
+  };
+  family.getCache = () => cache;
+  return family;
+}
+
+// src/internal/store.ts
+var PENDING_STATE = {
+  status: "pending",
+  value: void 0,
+  error: void 0
+};
+var Store = class {
+  #atoms = /* @__PURE__ */ new WeakMap();
+  #rdeps = /* @__PURE__ */ new Map();
+  #pending = /* @__PURE__ */ new Set();
+  #controllers = /* @__PURE__ */ new WeakMap();
+  #familyUnsubs = /* @__PURE__ */ new Set();
+  #registeredFamilies = /* @__PURE__ */ new WeakSet();
+  #client = null;
+  #getOrCreate(atom2) {
+    let entry = this.#atoms.get(atom2);
+    if (entry == null) {
+      entry = {
+        state: PENDING_STATE,
+        version: 0,
+        promise: null,
+        listeners: /* @__PURE__ */ new Set()
+      };
+      this.#atoms.set(atom2, entry);
+    }
+    return entry;
+  }
+  resolve(atom2) {
+    const entry = this.#getOrCreate(atom2);
+    if (entry.promise != null) {
+      return entry.promise;
+    }
+    const promise = this.#runGet(atom2).finally(() => {
+      const e = this.#atoms.get(atom2);
+      if (e != null) {
+        e.promise = null;
+      }
+    });
+    entry.promise = promise;
+    return promise;
+  }
+  async #runGet(atom2) {
+    const config = atom2[CONFIG];
+    const dependencies = config.dependencies;
+    const stalePolicy = config.stalePolicy ?? "keep";
+    const entry = this.#getOrCreate(atom2);
+    if (dependencies != null) {
+      await Promise.all(Object.values(dependencies).map((dep) => this.resolve(dep)));
+      this.#registerRdeps(atom2, dependencies);
+    }
+    const ctx = this.#makeCtx(atom2, dependencies ?? {});
+    try {
+      const value = await config.get(ctx);
+      entry.state = { status: "fresh", value, error: void 0 };
+      entry.version++;
+      this.#scheduleNotify(atom2);
+      return value;
+    } catch (e) {
+      if (isAbortError(e)) {
+        throw e;
+      }
+      const prevValue = extractPreviousValue(entry.state);
+      entry.state = {
+        status: "error",
+        value: stalePolicy === "keep" ? prevValue : void 0,
+        error: e
+      };
+      entry.version++;
+      this.#scheduleNotify(atom2);
+      throw e;
+    }
+  }
+  invalidate(atom2) {
+    this.#markStale(atom2);
+    this.#pending.add(atom2);
+    if (this.#pending.size === 1) {
+      queueMicrotask(() => {
+        this.#flushPending();
+      });
+    }
+  }
+  invalidateMany(atoms) {
+    for (const a of atoms) {
+      this.#markStale(a);
+      this.#pending.add(a);
+    }
+    if (this.#pending.size > 0) {
+      queueMicrotask(() => {
+        this.#flushPending();
+      });
+    }
+  }
+  #markStale(atom2, visited = /* @__PURE__ */ new Set()) {
+    if (visited.has(atom2)) {
+      return;
+    }
+    visited.add(atom2);
+    const entry = this.#atoms.get(atom2);
+    if (entry != null) {
+      const stalePolicy = atom2[CONFIG].stalePolicy ?? "keep";
+      if (entry.state.status === "fresh") {
+        if (stalePolicy === "reset") {
+          entry.state = PENDING_STATE;
+        } else {
+          entry.state = { ...entry.state, status: "stale" };
+        }
+      }
+      entry.promise = null;
+      this.#controllers.get(atom2)?.abort();
+    }
+    const rdeps = this.#rdeps.get(atom2);
+    if (rdeps != null) {
+      for (const dep of rdeps) {
+        this.#markStale(dep, visited);
+      }
+    }
+  }
+  #flushPending() {
+    const batch = [...this.#pending];
+    this.#pending.clear();
+    const toNotify = /* @__PURE__ */ new Set();
+    for (const a of batch) {
+      const entry = this.#atoms.get(a);
+      if (entry != null) {
+        for (const l of entry.listeners) {
+          toNotify.add(l);
+        }
+      }
+    }
+    for (const l of toNotify) {
+      l();
+    }
+  }
+  #scheduleNotify(atom2) {
+    this.#pending.add(atom2);
+    if (this.#pending.size === 1) {
+      queueMicrotask(() => {
+        this.#flushPending();
+      });
+    }
+  }
+  #registerRdeps(atom2, deps) {
+    for (const dep of Object.values(deps)) {
+      let set = this.#rdeps.get(dep);
+      if (set == null) {
+        set = /* @__PURE__ */ new Set();
+        this.#rdeps.set(dep, set);
+      }
+      set.add(atom2);
+    }
+  }
+  #makeCtx(atom2, deps) {
+    this.#controllers.get(atom2)?.abort();
+    const controller = new AbortController();
+    this.#controllers.set(atom2, controller);
+    return {
+      signal: controller.signal,
+      get: async (key) => {
+        const dep = deps[key];
+        if (dep == null) {
+          throw new Error(`Unknown dependency key: "${String(key)}"`);
+        }
+        return this.resolve(dep);
+      }
+    };
+  }
+  subscribe(atom2, listener) {
+    const entry = this.#getOrCreate(atom2);
+    entry.listeners.add(listener);
+    this.#autoRegisterFamily(atom2);
+    if (entry.state.status === "pending" && entry.promise == null) {
+      void this.resolve(atom2);
+    }
+    return () => {
+      entry.listeners.delete(listener);
+    };
+  }
+  #autoRegisterFamily(atom2) {
+    const link = getFamilyLink(atom2);
+    if (link == null) {
+      return;
+    }
+    if (this.#registeredFamilies.has(link)) {
+      return;
+    }
+    this.#registeredFamilies.add(link);
+    const unsub = link.registerStore((target) => {
+      this.invalidate(target);
+    });
+    this.#familyUnsubs.add(unsub);
+  }
+  getSnapshot(atom2) {
+    return this.#getOrCreate(atom2).state;
+  }
+  getServerSnapshot(atom2) {
+    const entry = this.#atoms.get(atom2);
+    if (entry != null) {
+      return entry.state;
+    }
+    return PENDING_STATE;
+  }
+  async set(atom2, ...args) {
+    const config = atom2[CONFIG];
+    if (config.set == null) {
+      throw new Error(
+        `Atom${atom2.debugLabel != null ? ` "${atom2.debugLabel}"` : ""} is not writable`
+      );
+    }
+    const deps = config.dependencies ?? {};
+    const ctx = this.#makeCtx(atom2, deps);
+    await config.set(ctx, ...args);
+    this.invalidate(atom2);
+  }
+  getClient() {
+    if (this.#client != null) {
+      return this.#client;
+    }
+    const store = this;
+    this.#client = {
+      get(atom2) {
+        return store.resolve(atom2);
+      },
+      set(atom2, ...args) {
+        return store.set(atom2, ...args);
+      },
+      invalidate(atom2) {
+        store.invalidate(atom2);
+      },
+      invalidateMany(atoms) {
+        store.invalidateMany(atoms);
+      },
+      subscribe(atom2, listener) {
+        return store.subscribe(atom2, () => {
+          listener(store.getSnapshot(atom2));
+        });
+      }
+    };
+    return this.#client;
+  }
+};
+function createStore() {
+  return new Store();
+}
+function isAbortError(e) {
+  return e instanceof DOMException && e.name === "AbortError";
+}
+function extractPreviousValue(state) {
+  if (state.status === "stale" || state.status === "fresh") {
+    return state.value;
+  }
+  if (state.status === "error") {
+    return state.value;
+  }
+  return void 0;
+}
+
+export {
+  CONFIG,
+  atom,
+  atomFamily,
+  createStore
+};
+//# sourceMappingURL=chunk-6WIZ6MFN.js.map

package/dist/chunk-6WIZ6MFN.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/internal/types.ts","../src/internal/atom.ts","../src/internal/family.ts","../src/internal/store.ts"],"sourcesContent":["export const CONFIG = Symbol(\"kvark.config\");\nexport const WRITABLE = Symbol(\"kvark.writable\");\nexport const FAMILY_LINK = Symbol(\"kvark.familyLink\");\n\nexport type AtomState<Value> =\n  | { status: \"pending\"; value: undefined; error: undefined }\n  | { status: \"stale\"; value: Value; error: undefined }\n  | { status: \"fresh\"; value: Value; error: undefined }\n  | { status: \"error\"; value: Value | undefined; error: unknown };\n\nexport type StalePolicy = \"keep\" | \"suspend\" | \"reset\";\n\nexport type AtomContext<Deps extends Record<string, Atom<unknown>>> = {\n  get: <K extends keyof Deps>(key: K) => Promise<AtomValue<Deps[K]>>;\n  signal: AbortSignal;\n};\n\nexport type AtomConfig<\n  Value,\n  Deps extends Record<string, Atom<unknown>>,\n  Args extends readonly unknown[],\n> = {\n  dependencies?: Deps;\n  stalePolicy?: StalePolicy;\n  debugLabel?: string;\n  get: (ctx: AtomContext<Deps>) => Promise<Value>;\n  set?: (ctx: AtomContext<Deps>, ...args: Args) => Promise<void>;\n};\n\nexport interface InternalAtomConfig<Value> {\n  dependencies?: Record<string, Atom<unknown>>;\n  stalePolicy?: StalePolicy;\n  debugLabel?: string;\n  get: (ctx: AtomContext<Record<string, Atom<unknown>>>) => Promise<Value>;\n  set?: (\n    ctx: AtomContext<Record<string, Atom<unknown>>>,\n    ...args: readonly unknown[]\n  ) => Promise<void>;\n}\n\nexport interface Atom<out Value> {\n  readonly [CONFIG]: InternalAtomConfig<Value>;\n  readonly debugLabel: string | undefined;\n}\n\nexport interface WritableAtom<\n  out Value,\n  in out Args extends readonly unknown[],\n> extends Atom<Value> {\n  readonly [WRITABLE]: Args;\n}\n\nexport type AtomValue<A> = A extends Atom<infer V> ? V : never;\nexport type IsWritable<A> = A extends WritableAtom<unknown, readonly unknown[]> ? true : false;\nexport type AtomArgs<A> = A extends WritableAtom<unknown, infer Args> ? Args : never;\n","import type { Atom, AtomConfig, AtomContext, InternalAtomConfig, WritableAtom } from \"./types.js\";\nimport { CONFIG, WRITABLE } from \"./types.js\";\n\ntype WritableConfig<\n  Value,\n  Deps extends Record<string, Atom<unknown>>,\n  Args extends readonly unknown[],\n> = AtomConfig<Value, Deps, Args> & {\n  set: (ctx: AtomContext<Deps>, ...args: Args) => Promise<void>;\n};\n\ntype ReadonlyConfig<Value, Deps extends Record<string, Atom<unknown>>> = Omit<\n  AtomConfig<Value, Deps, readonly []>,\n  \"set\"\n>;\n\nexport function atom<\n  Value,\n  Deps extends Record<string, Atom<unknown>> = Record<never, never>,\n  Args extends readonly unknown[] = readonly [],\n>(config: WritableConfig<Value, Deps, Args>): WritableAtom<Value, Args>;\n\nexport function atom<Value, Deps extends Record<string, Atom<unknown>> = Record<never, never>>(\n  config: ReadonlyConfig<Value, Deps>,\n): Atom<Value>;\n\nexport function atom<\n  Value,\n  Deps extends Record<string, Atom<unknown>> = Record<never, never>,\n  Args extends readonly unknown[] = readonly [],\n>(config: AtomConfig<Value, Deps, Args>): Atom<Value> {\n  const internal: InternalAtomConfig<Value> = Object.create(null) as InternalAtomConfig<Value>;\n  internal.get = config.get as InternalAtomConfig<Value>[\"get\"];\n\n  if (config.debugLabel != null) {\n    internal.debugLabel = config.debugLabel;\n  }\n  if (config.dependencies != null) {\n    internal.dependencies = config.dependencies as Record<string, Atom<unknown>>;\n  }\n  if (config.stalePolicy != null) {\n    internal.stalePolicy = config.stalePolicy;\n  }\n  if (config.set != null) {\n    internal.set = config.set as NonNullable<InternalAtomConfig<Value>[\"set\"]>;\n  }\n\n  if (config.set != null) {\n    return {\n      [CONFIG]: internal,\n      [WRITABLE]: [] as unknown as Args,\n      debugLabel: config.debugLabel,\n    } as unknown as Atom<Value>;\n  }\n\n  return {\n    [CONFIG]: internal,\n    debugLabel: config.debugLabel,\n  } as Atom<Value>;\n}\n","import type { Atom, AtomContext, StalePolicy } from \"./types.js\";\nimport { FAMILY_LINK } from \"./types.js\";\nimport { atom } from \"./atom.js\";\n\nexport type AtomFamilyOptions<\n  Param,\n  Value,\n  Deps extends Record<string, Atom<unknown>>,\n  Args extends readonly unknown[],\n> = {\n  dependencies?: (param: Param) => Deps;\n  stalePolicy?: StalePolicy;\n  cachePolicy?: \"keep-all\" | \"lru\";\n  lruSize?: number;\n  debugLabel?: string;\n  get: (param: Param) => (ctx: AtomContext<Deps>) => Promise<Value>;\n  set?: (param: Param) => (ctx: AtomContext<Deps>, ...args: Args) => Promise<void>;\n};\n\nexport interface AtomFamily<Param, Value> {\n  (param: Param): Atom<Value>;\n  invalidate(param: Param): void;\n  invalidateAll(): void;\n  remove(param: Param): void;\n  getCache(): ReadonlyMap<Param, Atom<Value>>;\n}\n\nexport interface FamilyLink {\n  invalidateAtom: (atom: Atom<unknown>) => void;\n  registerStore: (cb: (atom: Atom<unknown>) => void) => () => void;\n}\n\nexport function getFamilyLink(target: Atom<unknown>): FamilyLink | undefined {\n  return (target as unknown as Record<symbol, FamilyLink | undefined>)[FAMILY_LINK];\n}\n\nexport function atomFamily<\n  Param,\n  Value,\n  Deps extends Record<string, Atom<unknown>> = Record<never, never>,\n  Args extends readonly unknown[] = readonly [],\n>(options: AtomFamilyOptions<Param, Value, Deps, Args>): AtomFamily<Param, Value> {\n  const cachePolicy = options.cachePolicy ?? \"keep-all\";\n  const lruSize = options.lruSize ?? 100;\n  const cache = new Map<Param, Atom<Value>>();\n  const lruOrder: Param[] = [];\n  const storeCallbacks = new Set<(atom: Atom<unknown>) => void>();\n\n  const link: FamilyLink = {\n    invalidateAtom(target: Atom<unknown>): void {\n      for (const cb of storeCallbacks) {\n        cb(target);\n      }\n    },\n    registerStore(cb: (atom: Atom<unknown>) => void): () => void {\n      storeCallbacks.add(cb);\n      return () => {\n        storeCallbacks.delete(cb);\n      };\n    },\n  };\n\n  function attachLink(target: Atom<Value>): void {\n    (target as unknown as Record<symbol, FamilyLink>)[FAMILY_LINK] = link;\n  }\n\n  function getOrCreate(param: Param): Atom<Value> {\n    const cached = cache.get(param);\n    if (cached != null) {\n      if (cachePolicy === \"lru\") {\n        touchLru(param);\n      }\n      return cached;\n    }\n\n    const deps = options.dependencies?.(param);\n    const getFn = options.get(param);\n    const setFn = options.set?.(param);\n\n    const label =\n      options.debugLabel != null ? `${options.debugLabel}(${String(param)})` : undefined;\n\n    const created = createAtom(label, deps, getFn, setFn);\n    attachLink(created);\n    cache.set(param, created);\n\n    if (cachePolicy === \"lru\") {\n      lruOrder.push(param);\n      evictLru();\n    }\n\n    return created;\n  }\n\n  function createAtom(\n    label: string | undefined,\n    deps: Deps | undefined,\n    getFn: (ctx: AtomContext<Deps>) => Promise<Value>,\n    setFn: ((ctx: AtomContext<Deps>, ...args: Args) => Promise<void>) | undefined,\n  ): Atom<Value> {\n    const base = {\n      get: getFn as (ctx: AtomContext<Deps>) => Promise<Value>,\n    } as {\n      debugLabel?: string;\n      dependencies?: Deps;\n      stalePolicy?: StalePolicy;\n      get: (ctx: AtomContext<Deps>) => Promise<Value>;\n      set?: (ctx: AtomContext<Deps>, ...args: Args) => Promise<void>;\n    };\n\n    if (label != null) {\n      base.debugLabel = label;\n    }\n    if (deps != null) {\n      base.dependencies = deps;\n    }\n    if (options.stalePolicy != null) {\n      base.stalePolicy = options.stalePolicy;\n    }\n\n    if (setFn != null) {\n      base.set = setFn;\n      return atom(\n        base as typeof base & {\n          set: (ctx: AtomContext<Deps>, ...args: Args) => Promise<void>;\n        },\n      ) as Atom<Value>;\n    }\n\n    return atom(base as Omit<typeof base, \"set\">);\n  }\n\n  function touchLru(param: Param): void {\n    const idx = lruOrder.indexOf(param);\n    if (idx !== -1) {\n      lruOrder.splice(idx, 1);\n    }\n    lruOrder.push(param);\n  }\n\n  function evictLru(): void {\n    while (lruOrder.length > lruSize) {\n      const evicted = lruOrder.shift();\n      if (evicted !== undefined) {\n        cache.delete(evicted);\n      }\n    }\n  }\n\n  const family = getOrCreate as AtomFamily<Param, Value>;\n\n  family.invalidate = (param: Param): void => {\n    const cached = cache.get(param);\n    if (cached != null) {\n      link.invalidateAtom(cached);\n    }\n  };\n\n  family.invalidateAll = (): void => {\n    for (const cached of cache.values()) {\n      link.invalidateAtom(cached);\n    }\n  };\n\n  family.remove = (param: Param): void => {\n    cache.delete(param);\n    if (cachePolicy === \"lru\") {\n      const idx = lruOrder.indexOf(param);\n      if (idx !== -1) {\n        lruOrder.splice(idx, 1);\n      }\n    }\n  };\n\n  family.getCache = (): ReadonlyMap<Param, Atom<Value>> => cache;\n\n  return family;\n}\n","import type {\n  Atom,\n  AtomContext,\n  AtomState,\n  InternalAtomConfig,\n  StalePolicy,\n  WritableAtom,\n} from \"./types.js\";\nimport { CONFIG } from \"./types.js\";\nimport { getFamilyLink } from \"./family.js\";\n\ntype AtomEntry<V> = {\n  state: AtomState<V>;\n  version: number;\n  promise: Promise<V> | null;\n  listeners: Set<() => void>;\n};\n\nexport interface StoreClient {\n  get<V>(atom: Atom<V>): Promise<V>;\n  set<V, A extends readonly unknown[]>(atom: WritableAtom<V, A>, ...args: A): Promise<void>;\n  invalidate(atom: Atom<unknown>): void;\n  invalidateMany(atoms: ReadonlyArray<Atom<unknown>>): void;\n  subscribe<V>(atom: Atom<V>, listener: (state: AtomState<V>) => void): () => void;\n}\n\nconst PENDING_STATE: AtomState<never> = {\n  status: \"pending\",\n  value: undefined,\n  error: undefined,\n} as AtomState<never>;\n\nexport class Store {\n  readonly #atoms = new WeakMap<Atom<unknown>, AtomEntry<unknown>>();\n  readonly #rdeps = new Map<Atom<unknown>, Set<Atom<unknown>>>();\n  readonly #pending = new Set<Atom<unknown>>();\n  readonly #controllers = new WeakMap<Atom<unknown>, AbortController>();\n  readonly #familyUnsubs = new Set<() => void>();\n  readonly #registeredFamilies = new WeakSet<object>();\n  #client: StoreClient | null = null;\n\n  #getOrCreate<V>(atom: Atom<V>): AtomEntry<V> {\n    let entry = this.#atoms.get(atom) as AtomEntry<V> | undefined;\n    if (entry == null) {\n      entry = {\n        state: PENDING_STATE as AtomState<V>,\n        version: 0,\n        promise: null,\n        listeners: new Set(),\n      };\n      this.#atoms.set(atom, entry as AtomEntry<unknown>);\n    }\n    return entry;\n  }\n\n  resolve<V>(atom: Atom<V>): Promise<V> {\n    const entry = this.#getOrCreate(atom);\n    if (entry.promise != null) {\n      return entry.promise;\n    }\n\n    const promise = this.#runGet(atom).finally(() => {\n      const e = this.#atoms.get(atom) as AtomEntry<V> | undefined;\n      if (e != null) {\n        e.promise = null;\n      }\n    });\n    entry.promise = promise;\n    return promise;\n  }\n\n  async #runGet<V>(atom: Atom<V>): Promise<V> {\n    const config: InternalAtomConfig<V> = atom[CONFIG];\n    const dependencies = config.dependencies;\n    const stalePolicy: StalePolicy = config.stalePolicy ?? \"keep\";\n    const entry = this.#getOrCreate(atom);\n\n    if (dependencies != null) {\n      await Promise.all(Object.values(dependencies).map((dep) => this.resolve(dep)));\n      this.#registerRdeps(atom, dependencies);\n    }\n\n    const ctx = this.#makeCtx(atom, dependencies ?? {});\n\n    try {\n      const value = await config.get(ctx);\n      entry.state = { status: \"fresh\", value, error: undefined };\n      entry.version++;\n      this.#scheduleNotify(atom);\n      return value;\n    } catch (e: unknown) {\n      if (isAbortError(e)) {\n        throw e;\n      }\n      const prevValue = extractPreviousValue<V>(entry.state);\n      entry.state = {\n        status: \"error\",\n        value: stalePolicy === \"keep\" ? prevValue : undefined,\n        error: e,\n      } as AtomState<V>;\n      entry.version++;\n      this.#scheduleNotify(atom);\n      throw e;\n    }\n  }\n\n  invalidate(atom: Atom<unknown>): void {\n    this.#markStale(atom);\n    this.#pending.add(atom);\n    if (this.#pending.size === 1) {\n      queueMicrotask(() => {\n        this.#flushPending();\n      });\n    }\n  }\n\n  invalidateMany(atoms: ReadonlyArray<Atom<unknown>>): void {\n    for (const a of atoms) {\n      this.#markStale(a);\n      this.#pending.add(a);\n    }\n    if (this.#pending.size > 0) {\n      queueMicrotask(() => {\n        this.#flushPending();\n      });\n    }\n  }\n\n  #markStale(atom: Atom<unknown>, visited = new Set<Atom<unknown>>()): void {\n    if (visited.has(atom)) {\n      return;\n    }\n    visited.add(atom);\n\n    const entry = this.#atoms.get(atom);\n    if (entry != null) {\n      const stalePolicy: StalePolicy = atom[CONFIG].stalePolicy ?? \"keep\";\n\n      if (entry.state.status === \"fresh\") {\n        if (stalePolicy === \"reset\") {\n          entry.state = PENDING_STATE;\n        } else {\n          entry.state = { ...entry.state, status: \"stale\" };\n        }\n      }\n\n      entry.promise = null;\n      this.#controllers.get(atom)?.abort();\n    }\n\n    const rdeps = this.#rdeps.get(atom);\n    if (rdeps != null) {\n      for (const dep of rdeps) {\n        this.#markStale(dep, visited);\n      }\n    }\n  }\n\n  #flushPending(): void {\n    const batch = [...this.#pending];\n    this.#pending.clear();\n    const toNotify = new Set<() => void>();\n    for (const a of batch) {\n      const entry = this.#atoms.get(a);\n      if (entry != null) {\n        for (const l of entry.listeners) {\n          toNotify.add(l);\n        }\n      }\n    }\n    for (const l of toNotify) {\n      l();\n    }\n  }\n\n  #scheduleNotify(atom: Atom<unknown>): void {\n    this.#pending.add(atom);\n    if (this.#pending.size === 1) {\n      queueMicrotask(() => {\n        this.#flushPending();\n      });\n    }\n  }\n\n  #registerRdeps(atom: Atom<unknown>, deps: Record<string, Atom<unknown>>): void {\n    for (const dep of Object.values(deps)) {\n      let set = this.#rdeps.get(dep);\n      if (set == null) {\n        set = new Set();\n        this.#rdeps.set(dep, set);\n      }\n      set.add(atom);\n    }\n  }\n\n  #makeCtx(\n    atom: Atom<unknown>,\n    deps: Record<string, Atom<unknown>>,\n  ): AtomContext<Record<string, Atom<unknown>>> {\n    this.#controllers.get(atom)?.abort();\n    const controller = new AbortController();\n    this.#controllers.set(atom, controller);\n\n    return {\n      signal: controller.signal,\n      get: async (key: string) => {\n        const dep = deps[key];\n        if (dep == null) {\n          throw new Error(`Unknown dependency key: \"${String(key)}\"`);\n        }\n        return this.resolve(dep);\n      },\n    };\n  }\n\n  subscribe<V>(atom: Atom<V>, listener: () => void): () => void {\n    const entry = this.#getOrCreate(atom);\n    entry.listeners.add(listener);\n\n    this.#autoRegisterFamily(atom);\n\n    if (entry.state.status === \"pending\" && entry.promise == null) {\n      void this.resolve(atom);\n    }\n\n    return () => {\n      entry.listeners.delete(listener);\n    };\n  }\n\n  #autoRegisterFamily(atom: Atom<unknown>): void {\n    const link = getFamilyLink(atom);\n    if (link == null) {\n      return;\n    }\n    if (this.#registeredFamilies.has(link)) {\n      return;\n    }\n    this.#registeredFamilies.add(link);\n    const unsub = link.registerStore((target: Atom<unknown>) => {\n      this.invalidate(target);\n    });\n    this.#familyUnsubs.add(unsub);\n  }\n\n  getSnapshot<V>(atom: Atom<V>): AtomState<V> {\n    return this.#getOrCreate(atom).state;\n  }\n\n  getServerSnapshot<V>(atom: Atom<V>): AtomState<V> {\n    const entry = this.#atoms.get(atom) as AtomEntry<V> | undefined;\n    if (entry != null) {\n      return entry.state;\n    }\n    return PENDING_STATE as AtomState<V>;\n  }\n\n  async set<V, A extends readonly unknown[]>(atom: WritableAtom<V, A>, ...args: A): Promise<void> {\n    const config: InternalAtomConfig<V> = atom[CONFIG];\n    if (config.set == null) {\n      throw new Error(\n        `Atom${atom.debugLabel != null ? ` \"${atom.debugLabel}\"` : \"\"} is not writable`,\n      );\n    }\n\n    const deps = config.dependencies ?? {};\n    const ctx = this.#makeCtx(atom, deps);\n    await config.set(ctx, ...args);\n    this.invalidate(atom);\n  }\n\n  getClient(): StoreClient {\n    if (this.#client != null) {\n      return this.#client;\n    }\n\n    const store = this;\n    this.#client = {\n      get<V>(atom: Atom<V>): Promise<V> {\n        return store.resolve(atom);\n      },\n      set<V, A extends readonly unknown[]>(atom: WritableAtom<V, A>, ...args: A): Promise<void> {\n        return store.set(atom, ...args);\n      },\n      invalidate(atom: Atom<unknown>): void {\n        store.invalidate(atom);\n      },\n      invalidateMany(atoms: ReadonlyArray<Atom<unknown>>): void {\n        store.invalidateMany(atoms);\n      },\n      subscribe<V>(atom: Atom<V>, listener: (state: AtomState<V>) => void): () => void {\n        return store.subscribe(atom, () => {\n          listener(store.getSnapshot(atom));\n        });\n      },\n    };\n    return this.#client;\n  }\n}\n\nexport function createStore(): Store {\n  return new Store();\n}\n\nfunction isAbortError(e: unknown): boolean {\n  return e instanceof DOMException && e.name === \"AbortError\";\n}\n\nfunction extractPreviousValue<V>(state: AtomState<V>): V | undefined {\n  if (state.status === \"stale\" || state.status === \"fresh\") {\n    return state.value;\n  }\n  if (state.status === \"error\") {\n    return state.value;\n  }\n  return undefined;\n}\n"],"mappings":"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","names":["atom"]}

package/dist/family.d.ts

@@ -0,0 +1,23 @@
+import { A as Atom, S as StalePolicy, a as AtomContext } from './store-DwEjhc31.js';
+export { b as AtomConfig, c as AtomState, d as AtomValue, W as WritableAtom, e as createStore } from './store-DwEjhc31.js';
+export { atom } from './index.js';
+
+type AtomFamilyOptions<Param, Value, Deps extends Record<string, Atom<unknown>>, Args extends readonly unknown[]> = {
+    dependencies?: (param: Param) => Deps;
+    stalePolicy?: StalePolicy;
+    cachePolicy?: "keep-all" | "lru";
+    lruSize?: number;
+    debugLabel?: string;
+    get: (param: Param) => (ctx: AtomContext<Deps>) => Promise<Value>;
+    set?: (param: Param) => (ctx: AtomContext<Deps>, ...args: Args) => Promise<void>;
+};
+interface AtomFamily<Param, Value> {
+    (param: Param): Atom<Value>;
+    invalidate(param: Param): void;
+    invalidateAll(): void;
+    remove(param: Param): void;
+    getCache(): ReadonlyMap<Param, Atom<Value>>;
+}
+declare function atomFamily<Param, Value, Deps extends Record<string, Atom<unknown>> = Record<never, never>, Args extends readonly unknown[] = readonly []>(options: AtomFamilyOptions<Param, Value, Deps, Args>): AtomFamily<Param, Value>;
+
+export { Atom, AtomContext, type AtomFamily, type AtomFamilyOptions, StalePolicy, atomFamily };

package/dist/family.js

@@ -0,0 +1,11 @@
+import {
+  atom,
+  atomFamily,
+  createStore
+} from "./chunk-6WIZ6MFN.js";
+export {
+  atom,
+  atomFamily,
+  createStore
+};
+//# sourceMappingURL=family.js.map

package/dist/family.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { A as Atom, b as AtomConfig, a as AtomContext, W as WritableAtom } from './store-DwEjhc31.js';
+export { h as AtomArgs, c as AtomState, d as AtomValue, I as IsWritable, S as StalePolicy, g as StoreClient, e as createStore } from './store-DwEjhc31.js';
+
+type WritableConfig<Value, Deps extends Record<string, Atom<unknown>>, Args extends readonly unknown[]> = AtomConfig<Value, Deps, Args> & {
+    set: (ctx: AtomContext<Deps>, ...args: Args) => Promise<void>;
+};
+type ReadonlyConfig<Value, Deps extends Record<string, Atom<unknown>>> = Omit<AtomConfig<Value, Deps, readonly []>, "set">;
+declare function atom<Value, Deps extends Record<string, Atom<unknown>> = Record<never, never>, Args extends readonly unknown[] = readonly []>(config: WritableConfig<Value, Deps, Args>): WritableAtom<Value, Args>;
+declare function atom<Value, Deps extends Record<string, Atom<unknown>> = Record<never, never>>(config: ReadonlyConfig<Value, Deps>): Atom<Value>;
+
+export { Atom, AtomConfig, AtomContext, WritableAtom, atom };

package/dist/index.js

@@ -0,0 +1,9 @@
+import {
+  atom,
+  createStore
+} from "./chunk-6WIZ6MFN.js";
+export {
+  atom,
+  createStore
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/react/index.d.ts

@@ -0,0 +1,27 @@
+import { ReactNode } from 'react';
+import { f as Store, A as Atom, W as WritableAtom, g as StoreClient } from '../store-DwEjhc31.js';
+
+type ProviderProps = {
+    store: Store;
+    children: ReactNode;
+};
+declare function Provider({ store, children }: ProviderProps): ReactNode;
+declare function useStore(): Store;
+
+type ObservedValue<V> = {
+    value: V;
+    isStale: boolean;
+    error: unknown;
+};
+declare function useAtomValue<V>(atom: Atom<V>): V;
+declare function useAtomValue<V>(atom: Atom<V>, opts: {
+    observe: true;
+}): ObservedValue<V>;
+
+declare function useSetAtom<V, A extends readonly unknown[]>(atom: WritableAtom<V, A>): (...args: A) => Promise<void>;
+
+declare function useAtom<V, A extends readonly unknown[]>(atom: WritableAtom<V, A>): readonly [V, (...args: A) => Promise<void>];
+
+declare function useAtomCallback<R>(callback: (ctx: StoreClient) => Promise<R>): () => Promise<R>;
+
+export { Provider, useAtom, useAtomCallback, useAtomValue, useSetAtom, useStore };

package/dist/react/index.js

@@ -0,0 +1,87 @@
+import {
+  CONFIG
+} from "../chunk-6WIZ6MFN.js";
+
+// src/react/provider.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var StoreContext = createContext(null);
+function Provider({ store, children }) {
+  return /* @__PURE__ */ jsx(StoreContext, { value: store, children });
+}
+function useStore() {
+  const store = useContext(StoreContext);
+  if (store == null) {
+    throw new Error("useStore must be used within a <Provider>");
+  }
+  return store;
+}
+
+// src/react/use-atom-value.ts
+import { useSyncExternalStore } from "react";
+function useAtomValue(atom, opts) {
+  const store = useStore();
+  const snapshot = useSyncExternalStore(
+    (notify) => store.subscribe(atom, notify),
+    () => store.getSnapshot(atom),
+    () => store.getServerSnapshot(atom)
+  );
+  const stalePolicy = atom[CONFIG].stalePolicy ?? "keep";
+  if (snapshot.status === "pending") {
+    throw store.resolve(atom);
+  }
+  if (snapshot.status === "stale") {
+    if (stalePolicy === "suspend") {
+      throw store.resolve(atom);
+    }
+    void store.resolve(atom);
+    if (opts?.observe === true) {
+      return { value: snapshot.value, isStale: true, error: void 0 };
+    }
+    return snapshot.value;
+  }
+  if (snapshot.status === "error") {
+    if (opts?.observe === true && snapshot.value !== void 0) {
+      return {
+        value: snapshot.value,
+        isStale: false,
+        error: snapshot.error
+      };
+    }
+    throw snapshot.error;
+  }
+  if (opts?.observe === true) {
+    return { value: snapshot.value, isStale: false, error: void 0 };
+  }
+  return snapshot.value;
+}
+
+// src/react/use-set-atom.ts
+import { useCallback } from "react";
+function useSetAtom(atom) {
+  const store = useStore();
+  return useCallback((...args) => store.set(atom, ...args), [store, atom]);
+}
+
+// src/react/use-atom.ts
+function useAtom(atom) {
+  const value = useAtomValue(atom);
+  const setter = useSetAtom(atom);
+  return [value, setter];
+}
+
+// src/react/use-atom-callback.ts
+import { useCallback as useCallback2 } from "react";
+function useAtomCallback(callback) {
+  const store = useStore();
+  return useCallback2(() => callback(store.getClient()), [store, callback]);
+}
+export {
+  Provider,
+  useAtom,
+  useAtomCallback,
+  useAtomValue,
+  useSetAtom,
+  useStore
+};
+//# sourceMappingURL=index.js.map

package/dist/react/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/react/provider.tsx","../../src/react/use-atom-value.ts","../../src/react/use-set-atom.ts","../../src/react/use-atom.ts","../../src/react/use-atom-callback.ts"],"sourcesContent":["import { createContext, useContext, type ReactNode } from \"react\";\nimport { Store } from \"../internal/store.js\";\n\nconst StoreContext = createContext<Store | null>(null);\n\nexport type ProviderProps = {\n  store: Store;\n  children: ReactNode;\n};\n\nexport function Provider({ store, children }: ProviderProps): ReactNode {\n  return <StoreContext value={store}>{children}</StoreContext>;\n}\n\nexport function useStore(): Store {\n  const store = useContext(StoreContext);\n  if (store == null) {\n    throw new Error(\"useStore must be used within a <Provider>\");\n  }\n  return store;\n}\n","import { useSyncExternalStore } from \"react\";\nimport type { Atom, AtomState, StalePolicy } from \"../internal/types.js\";\nimport { CONFIG } from \"../internal/types.js\";\nimport { useStore } from \"./provider.js\";\n\ntype ObservedValue<V> = {\n  value: V;\n  isStale: boolean;\n  error: unknown;\n};\n\nexport function useAtomValue<V>(atom: Atom<V>): V;\nexport function useAtomValue<V>(atom: Atom<V>, opts: { observe: true }): ObservedValue<V>;\nexport function useAtomValue<V>(atom: Atom<V>, opts?: { observe: true }): V | ObservedValue<V> {\n  const store = useStore();\n\n  const snapshot: AtomState<V> = useSyncExternalStore(\n    (notify) => store.subscribe(atom, notify),\n    () => store.getSnapshot(atom),\n    () => store.getServerSnapshot(atom),\n  );\n\n  const stalePolicy: StalePolicy = atom[CONFIG].stalePolicy ?? \"keep\";\n\n  if (snapshot.status === \"pending\") {\n    throw store.resolve(atom);\n  }\n\n  if (snapshot.status === \"stale\") {\n    if (stalePolicy === \"suspend\") {\n      throw store.resolve(atom);\n    }\n    // \"keep\" or \"reset\" while stale: trigger background revalidation\n    void store.resolve(atom);\n\n    if (opts?.observe === true) {\n      return { value: snapshot.value, isStale: true, error: undefined };\n    }\n    return snapshot.value;\n  }\n\n  if (snapshot.status === \"error\") {\n    if (opts?.observe === true && snapshot.value !== undefined) {\n      return {\n        value: snapshot.value as V,\n        isStale: false,\n        error: snapshot.error,\n      };\n    }\n    throw snapshot.error;\n  }\n\n  // status === \"fresh\"\n  if (opts?.observe === true) {\n    return { value: snapshot.value, isStale: false, error: undefined };\n  }\n  return snapshot.value;\n}\n","import { useCallback } from \"react\";\nimport type { WritableAtom } from \"../internal/types.js\";\nimport { useStore } from \"./provider.js\";\n\nexport function useSetAtom<V, A extends readonly unknown[]>(\n  atom: WritableAtom<V, A>,\n): (...args: A) => Promise<void> {\n  const store = useStore();\n  return useCallback((...args: A): Promise<void> => store.set(atom, ...args), [store, atom]);\n}\n","import type { WritableAtom } from \"../internal/types.js\";\nimport { useAtomValue } from \"./use-atom-value.js\";\nimport { useSetAtom } from \"./use-set-atom.js\";\n\nexport function useAtom<V, A extends readonly unknown[]>(\n  atom: WritableAtom<V, A>,\n): readonly [V, (...args: A) => Promise<void>] {\n  const value = useAtomValue(atom);\n  const setter = useSetAtom(atom);\n  return [value, setter] as const;\n}\n","import { useCallback } from \"react\";\nimport type { StoreClient } from \"../internal/store.js\";\nimport { useStore } from \"./provider.js\";\n\nexport function useAtomCallback<R>(callback: (ctx: StoreClient) => Promise<R>): () => Promise<R> {\n  const store = useStore();\n  return useCallback((): Promise<R> => callback(store.getClient()), [store, callback]);\n}\n"],"mappings":";;;;;AAAA,SAAS,eAAe,kBAAkC;AAWjD;AART,IAAM,eAAe,cAA4B,IAAI;AAO9C,SAAS,SAAS,EAAE,OAAO,SAAS,GAA6B;AACtE,SAAO,oBAAC,gBAAa,OAAO,OAAQ,UAAS;AAC/C;AAEO,SAAS,WAAkB;AAChC,QAAM,QAAQ,WAAW,YAAY;AACrC,MAAI,SAAS,MAAM;AACjB,UAAM,IAAI,MAAM,2CAA2C;AAAA,EAC7D;AACA,SAAO;AACT;;;ACpBA,SAAS,4BAA4B;AAa9B,SAAS,aAAgB,MAAe,MAAgD;AAC7F,QAAM,QAAQ,SAAS;AAEvB,QAAM,WAAyB;AAAA,IAC7B,CAAC,WAAW,MAAM,UAAU,MAAM,MAAM;AAAA,IACxC,MAAM,MAAM,YAAY,IAAI;AAAA,IAC5B,MAAM,MAAM,kBAAkB,IAAI;AAAA,EACpC;AAEA,QAAM,cAA2B,KAAK,MAAM,EAAE,eAAe;AAE7D,MAAI,SAAS,WAAW,WAAW;AACjC,UAAM,MAAM,QAAQ,IAAI;AAAA,EAC1B;AAEA,MAAI,SAAS,WAAW,SAAS;AAC/B,QAAI,gBAAgB,WAAW;AAC7B,YAAM,MAAM,QAAQ,IAAI;AAAA,IAC1B;AAEA,SAAK,MAAM,QAAQ,IAAI;AAEvB,QAAI,MAAM,YAAY,MAAM;AAC1B,aAAO,EAAE,OAAO,SAAS,OAAO,SAAS,MAAM,OAAO,OAAU;AAAA,IAClE;AACA,WAAO,SAAS;AAAA,EAClB;AAEA,MAAI,SAAS,WAAW,SAAS;AAC/B,QAAI,MAAM,YAAY,QAAQ,SAAS,UAAU,QAAW;AAC1D,aAAO;AAAA,QACL,OAAO,SAAS;AAAA,QAChB,SAAS;AAAA,QACT,OAAO,SAAS;AAAA,MAClB;AAAA,IACF;AACA,UAAM,SAAS;AAAA,EACjB;AAGA,MAAI,MAAM,YAAY,MAAM;AAC1B,WAAO,EAAE,OAAO,SAAS,OAAO,SAAS,OAAO,OAAO,OAAU;AAAA,EACnE;AACA,SAAO,SAAS;AAClB;;;ACzDA,SAAS,mBAAmB;AAIrB,SAAS,WACd,MAC+B;AAC/B,QAAM,QAAQ,SAAS;AACvB,SAAO,YAAY,IAAI,SAA2B,MAAM,IAAI,MAAM,GAAG,IAAI,GAAG,CAAC,OAAO,IAAI,CAAC;AAC3F;;;ACLO,SAAS,QACd,MAC6C;AAC7C,QAAM,QAAQ,aAAa,IAAI;AAC/B,QAAM,SAAS,WAAW,IAAI;AAC9B,SAAO,CAAC,OAAO,MAAM;AACvB;;;ACVA,SAAS,eAAAA,oBAAmB;AAIrB,SAAS,gBAAmB,UAA8D;AAC/F,QAAM,QAAQ,SAAS;AACvB,SAAOC,aAAY,MAAkB,SAAS,MAAM,UAAU,CAAC,GAAG,CAAC,OAAO,QAAQ,CAAC;AACrF;","names":["useCallback","useCallback"]}

package/dist/store-DwEjhc31.d.ts

@@ -0,0 +1,70 @@
+declare const CONFIG: unique symbol;
+declare const WRITABLE: unique symbol;
+type AtomState<Value> = {
+    status: "pending";
+    value: undefined;
+    error: undefined;
+} | {
+    status: "stale";
+    value: Value;
+    error: undefined;
+} | {
+    status: "fresh";
+    value: Value;
+    error: undefined;
+} | {
+    status: "error";
+    value: Value | undefined;
+    error: unknown;
+};
+type StalePolicy = "keep" | "suspend" | "reset";
+type AtomContext<Deps extends Record<string, Atom<unknown>>> = {
+    get: <K extends keyof Deps>(key: K) => Promise<AtomValue<Deps[K]>>;
+    signal: AbortSignal;
+};
+type AtomConfig<Value, Deps extends Record<string, Atom<unknown>>, Args extends readonly unknown[]> = {
+    dependencies?: Deps;
+    stalePolicy?: StalePolicy;
+    debugLabel?: string;
+    get: (ctx: AtomContext<Deps>) => Promise<Value>;
+    set?: (ctx: AtomContext<Deps>, ...args: Args) => Promise<void>;
+};
+interface InternalAtomConfig<Value> {
+    dependencies?: Record<string, Atom<unknown>>;
+    stalePolicy?: StalePolicy;
+    debugLabel?: string;
+    get: (ctx: AtomContext<Record<string, Atom<unknown>>>) => Promise<Value>;
+    set?: (ctx: AtomContext<Record<string, Atom<unknown>>>, ...args: readonly unknown[]) => Promise<void>;
+}
+interface Atom<out Value> {
+    readonly [CONFIG]: InternalAtomConfig<Value>;
+    readonly debugLabel: string | undefined;
+}
+interface WritableAtom<out Value, in out Args extends readonly unknown[]> extends Atom<Value> {
+    readonly [WRITABLE]: Args;
+}
+type AtomValue<A> = A extends Atom<infer V> ? V : never;
+type IsWritable<A> = A extends WritableAtom<unknown, readonly unknown[]> ? true : false;
+type AtomArgs<A> = A extends WritableAtom<unknown, infer Args> ? Args : never;
+
+interface StoreClient {
+    get<V>(atom: Atom<V>): Promise<V>;
+    set<V, A extends readonly unknown[]>(atom: WritableAtom<V, A>, ...args: A): Promise<void>;
+    invalidate(atom: Atom<unknown>): void;
+    invalidateMany(atoms: ReadonlyArray<Atom<unknown>>): void;
+    subscribe<V>(atom: Atom<V>, listener: (state: AtomState<V>) => void): () => void;
+}
+declare class Store {
+    #private;
+    resolve<V>(atom: Atom<V>): Promise<V>;
+    invalidate(atom: Atom<unknown>): void;
+    invalidateMany(atoms: ReadonlyArray<Atom<unknown>>): void;
+    subscribe<V>(atom: Atom<V>, listener: () => void): () => void;
+    getSnapshot<V>(atom: Atom<V>): AtomState<V>;
+    getServerSnapshot<V>(atom: Atom<V>): AtomState<V>;
+    set<V, A extends readonly unknown[]>(atom: WritableAtom<V, A>, ...args: A): Promise<void>;
+    getClient(): StoreClient;
+}
+declare function createStore(): Store;
+
+export { type Atom as A, type IsWritable as I, type StalePolicy as S, type WritableAtom as W, type AtomContext as a, type AtomConfig as b, type AtomState as c, type AtomValue as d, createStore as e, Store as f, type StoreClient as g, type AtomArgs as h };

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@kdeveloper/kvark",
+  "version": "0.1.1",
+  "description": "Atomic state management with explicit dependency graphs",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "import": "./dist/react/index.js"
+    },
+    "./family": {
+      "types": "./dist/family.d.ts",
+      "import": "./dist/family.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "lint": "oxlint --deny-warnings",
+    "lint:fix": "oxlint --fix --deny-warnings",
+    "lint:types": "tsc --noEmit",
+    "fmt": "oxfmt .",
+    "fmt:check": "oxfmt --check .",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "devDependencies": {
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/react": "^19.2.14",
+    "@types/react-dom": "^19.2.3",
+    "jsdom": "^29.0.1",
+    "oxfmt": "^0.42.0",
+    "oxlint": "^1.57.0",
+    "react": ">=18",
+    "react-dom": "^19.2.4",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.2"
+  },
+  "peerDependencies": {
+    "react": ">=18"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "packageManager": "pnpm@10.33.0"
+}