@kdeveloper/kvark 0.7.0 → 0.8.0

package/README.md

@@ -2,7 +2,7 @@
 
 [![npm version](https://img.shields.io/npm/v/@kdeveloper/kvark.svg)](https://www.npmjs.com/package/@kdeveloper/kvark)
 
-Atomic state management for **React** and **Vue 3** with **explicit dependency graphs**, stale-while-revalidate, and first-class external invalidation.
+Atomic state management for **React**, **Preact**, and **Vue 3** 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 framework hooks.
 
@@ -23,7 +23,7 @@ Inspired by Jotai, but built around a key difference: dependencies are declared
 
 ```bash
 pnpm add @kdeveloper/kvark
-# optional peers: react >=18 and/or vue >=3.4
+# optional peers: react >=18, preact >=10, and/or vue >=3.4
 ```
 
 ## Quick Start
@@ -70,6 +70,16 @@ function UserCard() {
 }
 ```
 
+### Preact
+
+The same atoms and store work with `@kdeveloper/kvark/preact` — the API is identical to the React integration. Replace the React import with the Preact one:
+
+```tsx
+import { Provider, useAtomValue, useSetAtom } from "@kdeveloper/kvark/preact";
+```
+
+Hooks use only `preact` and `preact/hooks` internally — no `preact/compat` aliases required.
+
 ### Vue 3
 
 The same atoms and store work with `@kdeveloper/kvark/vue`. Composables mirror the React hooks; `useAtomValue` returns an **awaitable** [`shallowRef`](https://vuejs.org/api/reactivity-advanced.html#shallowref) — use `.value` in `<script setup>` (templates unwrap refs automatically). Until the first `get` resolves, that ref’s value is `undefined`; TypeScript types it as `V | undefined` (`ThenableShallowRef<V>`). After `await useAtomValue(atom)` you get `Readonly<ShallowRef<V>>` with a defined `.value`. The ref also implements `PromiseLike`, so awaiting it in an async `setup` suspends until the first `get` resolves — see [Suspense (Vue 3)](#suspense-vue-3).
@@ -314,10 +324,10 @@ const store = createStore();
 await store.mutate(addItem, "new row");
 ```
 
-**React / Vue**
+**React / Preact / Vue**
 
 ```tsx
-import { useMutation } from "@kdeveloper/kvark/react";
+import { useMutation } from "@kdeveloper/kvark/react"; // or "@kdeveloper/kvark/preact"
 
 const runAddItem = useMutation(addItem);
 
@@ -332,7 +342,7 @@ const runAddItem = useMutation(addItem);
 </script>
 ```
 
-`useMutation` returns a stable function (React: `useCallback` over `store.mutate`) with the same argument tuple as your mutation.
+`useMutation` returns a stable function (React/Preact: `useCallback` over `store.mutate`) with the same argument tuple as your mutation.
 
 #### Writable atoms vs `onMount`
 
@@ -531,6 +541,12 @@ const readBalance = useAtomContext(async (client) => {
 const balance = await readBalance();
 ```
 
+## Preact (`@kdeveloper/kvark/preact`)
+
+Same hook names, signatures, and behaviour as the React integration: `Provider`, `useStore`, `useAtomValue`, `useSetAtom`, `useMutation`, `useAtom`, `useAtomContext`. All hooks must be used inside a `<Provider>`.
+
+Internally the entry imports only from `preact` and `preact/hooks` — there is **no dependency on `preact/compat`**, so your app does not need any React compatibility aliases.
+
 ## Vue 3 (`@kdeveloper/kvark/vue`)
 
 Same composable names and behaviour as React: `Provider`, `useStore`, `useAtomValue`, `useSetAtom`, `useMutation`, `useAtom`, `useAtomContext`. Wrap your app (or subtree) with `Provider` and pass `:store="store"`.
@@ -682,7 +698,7 @@ interface StoreClient {
 
 ## Provider and Store Setup
 
-**React**
+**React / Preact**
 
 ```tsx
 // store.ts
@@ -690,7 +706,7 @@ import { createStore } from "@kdeveloper/kvark";
 export const store = createStore();
 
 // App.tsx
-import { Provider } from "@kdeveloper/kvark/react";
+import { Provider } from "@kdeveloper/kvark/react"; // or "@kdeveloper/kvark/preact"
 import { store } from "./store";
 
 export function App() {
@@ -736,11 +752,12 @@ type Writable = IsWritable<typeof countAtom>; // → true | false
 | Import                     | Contents                                                                                                                                                                    |
 | -------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | `@kdeveloper/kvark`        | `atom`, `mutation`, `createStore`, all types (including `Mutation`, `MutationContext`)                                                                                      |
-| `@kdeveloper/kvark/react`  | `Provider`, `useStore`, `useAtomValue`, `useSetAtom`, `useMutation`, `useAtom`, `useAtomContext`                                                                            |
-| `@kdeveloper/kvark/vue`    | `Provider`, `useStore`, `useAtomValue`, `useSetAtom`, `useMutation`, `useAtom`, `useAtomContext`; types `ThenableShallowRef`, `ThenableObservedShallowRef`, `ObservedValue` |
+| `@kdeveloper/kvark/react`   | `Provider`, `useStore`, `useAtomValue`, `useSetAtom`, `useMutation`, `useAtom`, `useAtomContext`                                                                            |
+| `@kdeveloper/kvark/preact`  | `Provider`, `useStore`, `useAtomValue`, `useSetAtom`, `useMutation`, `useAtom`, `useAtomContext`                                                                            |
+| `@kdeveloper/kvark/vue`     | `Provider`, `useStore`, `useAtomValue`, `useSetAtom`, `useMutation`, `useAtom`, `useAtomContext`; types `ThenableShallowRef`, `ThenableObservedShallowRef`, `ObservedValue` |
 | `@kdeveloper/kvark/family` | `atomFamily`, `stableFamilyKey`, re-exports `atom`, `mutation`, `createStore`; types include `AtomFamily`, `Mutation`, `MutationContext`, and core atom types               |
 
-The core (`@kdeveloper/kvark`) has **zero runtime dependencies**. **React** and **Vue** are optional peer dependencies — install the framework you use and import from `/react` or `/vue`.
+The core (`@kdeveloper/kvark`) has **zero runtime dependencies**. **React**, **Preact**, and **Vue** are optional peer dependencies — install the framework you use and import from `/react`, `/preact`, or `/vue`.
 
 The published package is **ESM-only** (`import`); there is no CommonJS `require` entry.
 
@@ -763,6 +780,7 @@ Useful variants: `pnpm test:watch`, `pnpm lint:fix`, `pnpm fmt:check`, `pnpm lin
 - **Node.js** ≥ 20
 - **TypeScript** ≥ 6 (strict mode recommended)
 - **React** ≥ 18 (optional peer, for `@kdeveloper/kvark/react`)
+- **Preact** ≥ 10 (optional peer, for `@kdeveloper/kvark/preact`)
 - **Vue** ≥ 3.4 (optional peer, for `@kdeveloper/kvark/vue`)
 
 ## License

package/dist/preact/index.d.ts

@@ -0,0 +1,42 @@
+import { h as WritableAtom, i as Mutation, n as StoreClient, o as Atom, t as Store } from "../store-DLoedZQo.js";
+import { ComponentChildren, VNode } from "preact";
+
+//#region src/preact/provider.d.ts
+type ProviderProps = {
+  store: Store;
+  children: ComponentChildren;
+};
+declare function Provider({
+  store,
+  children
+}: ProviderProps): VNode;
+declare function useStore(): Store;
+//#endregion
+//#region src/preact/use-atom-value.d.ts
+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>;
+//#endregion
+//#region src/preact/use-set-atom.d.ts
+declare function useSetAtom<V, A extends readonly unknown[]>(atom: WritableAtom<V, A>): (...args: A) => Promise<void>;
+//#endregion
+//#region src/preact/use-mutation.d.ts
+declare function useMutation<Args extends readonly unknown[]>(mutation: Mutation<Args>): (...args: Args) => Promise<void>;
+//#endregion
+//#region src/preact/use-atom.d.ts
+declare function useAtom<V, A extends readonly unknown[]>(atom: WritableAtom<V, A>): readonly [V, (...args: A) => Promise<void>];
+//#endregion
+//#region src/preact/use-atom-context.d.ts
+declare function useAtomContext<R>(callback: (ctx: StoreClient) => Promise<R>): () => Promise<R>;
+//#endregion
+//#region src/preact/use-stable-fn.d.ts
+declare function useStableFn<Args extends unknown[], R>(fn: (...args: Args) => R): (...args: Args) => R;
+//#endregion
+export { Provider, useAtom, useAtomContext, useAtomValue, useMutation, useSetAtom, useStableFn, useStore };
+//# sourceMappingURL=index.d.ts.map

package/dist/preact/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/preact/provider.tsx","../../src/preact/use-atom-value.ts","../../src/preact/use-set-atom.ts","../../src/preact/use-mutation.ts","../../src/preact/use-atom.ts","../../src/preact/use-atom-context.ts","../../src/preact/use-stable-fn.ts"],"mappings":";;;;KAOY,aAAA;EACV,KAAA,EAAO,KAAA;EACP,QAAA,EAAU,iBAAA;AAAA;AAAA,iBAGI,QAAA,CAAA;EAAW,KAAA;EAAO;AAAA,GAAY,aAAA,GAAgB,KAAA;AAAA,iBAI9C,QAAA,CAAA,GAAY,KAAA;;;KCVvB,aAAA;EACH,KAAA,EAAO,CAAA;EACP,OAAA;EACA,KAAA;AAAA;AAAA,iBAGc,YAAA,GAAA,CAAgB,IAAA,EAAM,IAAA,CAAK,CAAA,IAAK,CAAA;AAAA,iBAChC,YAAA,GAAA,CAAgB,IAAA,EAAM,IAAA,CAAK,CAAA,GAAI,IAAA;EAAQ,OAAA;AAAA,IAAkB,aAAA,CAAc,CAAA;;;iBCTvE,UAAA,iCAAA,CACd,IAAA,EAAM,YAAA,CAAa,CAAA,EAAG,CAAA,QACjB,IAAA,EAAM,CAAA,KAAM,OAAA;;;iBCFH,WAAA,iCAAA,CACd,QAAA,EAAU,QAAA,CAAS,IAAA,QACd,IAAA,EAAM,IAAA,KAAS,OAAA;;;iBCFN,OAAA,iCAAA,CACd,IAAA,EAAM,YAAA,CAAa,CAAA,EAAG,CAAA,cACX,CAAA,MAAO,IAAA,EAAM,CAAA,KAAM,OAAA;;;iBCFhB,cAAA,GAAA,CAAkB,QAAA,GAAW,GAAA,EAAK,WAAA,KAAgB,OAAA,CAAQ,CAAA,UAAW,OAAA,CAAQ,CAAA;;;iBCF7E,WAAA,2BAAA,CACd,EAAA,MAAQ,IAAA,EAAM,IAAA,KAAS,CAAA,OAClB,IAAA,EAAM,IAAA,KAAS,CAAA"}

package/dist/preact/index.js

@@ -0,0 +1,116 @@
+import { t as CONFIG } from "../types-B2mzc3A5.js";
+import { createContext } from "preact";
+import { useCallback, useContext, useEffect, useLayoutEffect, useRef, useState } from "preact/hooks";
+import { jsx } from "preact/jsx-runtime";
+//#region src/preact/provider.tsx
+/** @jsxImportSource preact */
+const StoreContext = createContext(null);
+function Provider({ store, children }) {
+	return /* @__PURE__ */ jsx(StoreContext.Provider, {
+		value: store,
+		children
+	});
+}
+function useStore() {
+	const store = useContext(StoreContext);
+	if (store == null) throw new Error("useStore must be used within a <Provider>");
+	return store;
+}
+//#endregion
+//#region src/preact/use-sync-external-store.ts
+function didSnapshotChange(inst) {
+	try {
+		return !Object.is(inst._value, inst._getSnapshot());
+	} catch {
+		return true;
+	}
+}
+function useSyncExternalStore(subscribe, getSnapshot) {
+	const value = getSnapshot();
+	const [{ _instance }, forceUpdate] = useState(() => ({ _instance: {
+		_value: value,
+		_getSnapshot: getSnapshot
+	} }));
+	useLayoutEffect(() => {
+		_instance._value = value;
+		_instance._getSnapshot = getSnapshot;
+		if (didSnapshotChange(_instance)) forceUpdate({ _instance });
+	}, [
+		subscribe,
+		value,
+		getSnapshot
+	]);
+	useEffect(() => {
+		if (didSnapshotChange(_instance)) forceUpdate({ _instance });
+		return subscribe(() => {
+			if (didSnapshotChange(_instance)) forceUpdate({ _instance });
+		});
+	}, [subscribe]);
+	return value;
+}
+//#endregion
+//#region src/preact/use-stable-fn.ts
+function useStableFn(fn) {
+	const ref = useRef(fn);
+	ref.current = fn;
+	return useCallback((...args) => ref.current(...args), []);
+}
+//#endregion
+//#region src/preact/use-atom-value.ts
+function useAtomValue(atom, opts) {
+	const store = useStore();
+	const snapshot = useSyncExternalStore(useStableFn((notify) => store.subscribe(atom, notify)), useStableFn(() => store.getSnapshot(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);
+		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;
+}
+//#endregion
+//#region src/preact/use-set-atom.ts
+function useSetAtom(atom) {
+	const store = useStore();
+	return useCallback((...args) => store.set(atom, ...args), [store, atom]);
+}
+//#endregion
+//#region src/preact/use-mutation.ts
+function useMutation(mutation) {
+	const store = useStore();
+	return useCallback((...args) => store.mutate(mutation, ...args), [store, mutation]);
+}
+//#endregion
+//#region src/preact/use-atom.ts
+function useAtom(atom) {
+	return [useAtomValue(atom), useSetAtom(atom)];
+}
+//#endregion
+//#region src/preact/use-atom-context.ts
+function useAtomContext(callback) {
+	const store = useStore();
+	return useCallback(() => callback(store.getClient()), [store, callback]);
+}
+//#endregion
+export { Provider, useAtom, useAtomContext, useAtomValue, useMutation, useSetAtom, useStableFn, useStore };
+
+//# sourceMappingURL=index.js.map

package/dist/preact/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/preact/provider.tsx","../../src/preact/use-sync-external-store.ts","../../src/preact/use-stable-fn.ts","../../src/preact/use-atom-value.ts","../../src/preact/use-set-atom.ts","../../src/preact/use-mutation.ts","../../src/preact/use-atom.ts","../../src/preact/use-atom-context.ts"],"sourcesContent":["/** @jsxImportSource preact */\nimport { createContext, type ComponentChildren, type VNode } from \"preact\";\nimport { useContext } from \"preact/hooks\";\nimport type { Store } from \"@/internal/store.js\";\n\nconst StoreContext = createContext<Store | null>(null);\n\nexport type ProviderProps = {\n  store: Store;\n  children: ComponentChildren;\n};\n\nexport function Provider({ store, children }: ProviderProps): VNode {\n  return <StoreContext.Provider value={store}>{children}</StoreContext.Provider>;\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 { useState, useLayoutEffect, useEffect } from \"preact/hooks\";\n\n// Typed shim for useSyncExternalStore using only preact/hooks,\n// based on React's client shim that Preact ships in preact/compat.\n\ntype StoreInstance<T> = { _value: T; _getSnapshot: () => T };\n\nfunction didSnapshotChange<T>(inst: StoreInstance<T>): boolean {\n  try {\n    return !Object.is(inst._value, inst._getSnapshot());\n  } catch {\n    return true;\n  }\n}\n\nexport function useSyncExternalStore<T>(\n  subscribe: (onStoreChange: () => void) => () => void,\n  getSnapshot: () => T,\n): T {\n  const value = getSnapshot();\n\n  const [{ _instance }, forceUpdate] = useState(() => ({\n    _instance: { _value: value, _getSnapshot: getSnapshot } as StoreInstance<T>,\n  }));\n\n  useLayoutEffect(() => {\n    _instance._value = value;\n    _instance._getSnapshot = getSnapshot;\n\n    if (didSnapshotChange(_instance)) {\n      forceUpdate({ _instance });\n    }\n  }, [subscribe, value, getSnapshot]);\n\n  useEffect(() => {\n    if (didSnapshotChange(_instance)) {\n      forceUpdate({ _instance });\n    }\n\n    return subscribe(() => {\n      if (didSnapshotChange(_instance)) {\n        forceUpdate({ _instance });\n      }\n    });\n  }, [subscribe]);\n\n  return value;\n}\n","import { useCallback, useRef } from \"preact/hooks\";\n\nexport function useStableFn<Args extends unknown[], R>(\n  fn: (...args: Args) => R,\n): (...args: Args) => R {\n  const ref = useRef(fn);\n  ref.current = fn;\n\n  return useCallback((...args: Args) => ref.current(...args), []);\n}\n","import { useSyncExternalStore } from \"@/preact/use-sync-external-store.js\";\nimport type { Atom, AtomState, StalePolicy } from \"@/internal/types.js\";\nimport { CONFIG } from \"@/internal/types.js\";\nimport { useStore } from \"@/preact/provider.js\";\nimport { useStableFn } from \"@/preact/use-stable-fn.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 subscribe = useStableFn((notify: () => void) => store.subscribe(atom, notify));\n  const getSnapshot = useStableFn(() => store.getSnapshot(atom));\n\n  const snapshot: AtomState<V> = useSyncExternalStore(subscribe, getSnapshot);\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 \"preact/hooks\";\nimport type { WritableAtom } from \"@/internal/types.js\";\nimport { useStore } from \"@/preact/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 { useCallback } from \"preact/hooks\";\nimport type { Mutation } from \"@/internal/mutation.js\";\nimport { useStore } from \"@/preact/provider.js\";\n\nexport function useMutation<Args extends readonly unknown[]>(\n  mutation: Mutation<Args>,\n): (...args: Args) => Promise<void> {\n  const store = useStore();\n  return useCallback(\n    (...args: Args): Promise<void> => store.mutate(mutation, ...args),\n    [store, mutation],\n  );\n}\n","import type { WritableAtom } from \"@/internal/types.js\";\nimport { useAtomValue } from \"@/preact/use-atom-value.js\";\nimport { useSetAtom } from \"@/preact/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 \"preact/hooks\";\nimport type { StoreClient } from \"@/internal/store.js\";\nimport { useStore } from \"@/preact/provider.js\";\n\nexport function useAtomContext<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":";;;;;;AAKA,MAAM,eAAe,cAA4B,KAAK;AAOtD,SAAgB,SAAS,EAAE,OAAO,YAAkC;AAClE,QAAO,oBAAC,aAAa,UAAd;EAAuB,OAAO;EAAQ;EAAiC,CAAA;;AAGhF,SAAgB,WAAkB;CAChC,MAAM,QAAQ,WAAW,aAAa;AACtC,KAAI,SAAS,KACX,OAAM,IAAI,MAAM,4CAA4C;AAE9D,QAAO;;;;ACdT,SAAS,kBAAqB,MAAiC;AAC7D,KAAI;AACF,SAAO,CAAC,OAAO,GAAG,KAAK,QAAQ,KAAK,cAAc,CAAC;SAC7C;AACN,SAAO;;;AAIX,SAAgB,qBACd,WACA,aACG;CACH,MAAM,QAAQ,aAAa;CAE3B,MAAM,CAAC,EAAE,aAAa,eAAe,gBAAgB,EACnD,WAAW;EAAE,QAAQ;EAAO,cAAc;EAAa,EACxD,EAAE;AAEH,uBAAsB;AACpB,YAAU,SAAS;AACnB,YAAU,eAAe;AAEzB,MAAI,kBAAkB,UAAU,CAC9B,aAAY,EAAE,WAAW,CAAC;IAE3B;EAAC;EAAW;EAAO;EAAY,CAAC;AAEnC,iBAAgB;AACd,MAAI,kBAAkB,UAAU,CAC9B,aAAY,EAAE,WAAW,CAAC;AAG5B,SAAO,gBAAgB;AACrB,OAAI,kBAAkB,UAAU,CAC9B,aAAY,EAAE,WAAW,CAAC;IAE5B;IACD,CAAC,UAAU,CAAC;AAEf,QAAO;;;;AC5CT,SAAgB,YACd,IACsB;CACtB,MAAM,MAAM,OAAO,GAAG;AACtB,KAAI,UAAU;AAEd,QAAO,aAAa,GAAG,SAAe,IAAI,QAAQ,GAAG,KAAK,EAAE,EAAE,CAAC;;;;ACMjE,SAAgB,aAAgB,MAAe,MAAgD;CAC7F,MAAM,QAAQ,UAAU;CAKxB,MAAM,WAAyB,qBAHb,aAAa,WAAuB,MAAM,UAAU,MAAM,OAAO,CAAC,EAChE,kBAAkB,MAAM,YAAY,KAAK,CAAC,CAEa;CAE3E,MAAM,cAA2B,KAAK,QAAQ,eAAe;AAE7D,KAAI,SAAS,WAAW,UACtB,OAAM,MAAM,QAAQ,KAAK;AAG3B,KAAI,SAAS,WAAW,SAAS;AAC/B,MAAI,gBAAgB,UAClB,OAAM,MAAM,QAAQ,KAAK;AAGtB,QAAM,QAAQ,KAAK;AAExB,MAAI,MAAM,YAAY,KACpB,QAAO;GAAE,OAAO,SAAS;GAAO,SAAS;GAAM,OAAO,KAAA;GAAW;AAEnE,SAAO,SAAS;;AAGlB,KAAI,SAAS,WAAW,SAAS;AAC/B,MAAI,MAAM,YAAY,QAAQ,SAAS,UAAU,KAAA,EAC/C,QAAO;GACL,OAAO,SAAS;GAChB,SAAS;GACT,OAAO,SAAS;GACjB;AAEH,QAAM,SAAS;;AAIjB,KAAI,MAAM,YAAY,KACpB,QAAO;EAAE,OAAO,SAAS;EAAO,SAAS;EAAO,OAAO,KAAA;EAAW;AAEpE,QAAO,SAAS;;;;ACpDlB,SAAgB,WACd,MAC+B;CAC/B,MAAM,QAAQ,UAAU;AACxB,QAAO,aAAa,GAAG,SAA2B,MAAM,IAAI,MAAM,GAAG,KAAK,EAAE,CAAC,OAAO,KAAK,CAAC;;;;ACJ5F,SAAgB,YACd,UACkC;CAClC,MAAM,QAAQ,UAAU;AACxB,QAAO,aACJ,GAAG,SAA8B,MAAM,OAAO,UAAU,GAAG,KAAK,EACjE,CAAC,OAAO,SAAS,CAClB;;;;ACPH,SAAgB,QACd,MAC6C;AAG7C,QAAO,CAFO,aAAa,KAAK,EACjB,WAAW,KAAK,CACT;;;;ACLxB,SAAgB,eAAkB,UAA8D;CAC9F,MAAM,QAAQ,UAAU;AACxB,QAAO,kBAA8B,SAAS,MAAM,WAAW,CAAC,EAAE,CAAC,OAAO,SAAS,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kdeveloper/kvark",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Atomic state management with explicit dependency graphs",
   "license": "MIT",
   "files": [
@@ -19,6 +19,10 @@
       "types": "./dist/react/index.d.ts",
       "import": "./dist/react/index.js"
     },
+    "./preact": {
+      "types": "./dist/preact/index.d.ts",
+      "import": "./dist/preact/index.js"
+    },
     "./vue": {
       "types": "./dist/vue/index.d.ts",
       "import": "./dist/vue/index.js"
@@ -30,6 +34,7 @@
   },
   "devDependencies": {
     "@testing-library/dom": "^10.4.1",
+    "@testing-library/preact": "^3.2.4",
     "@testing-library/react": "^16.3.2",
     "@types/node": "^25.5.0",
     "@types/react": "^19.2.14",
@@ -39,6 +44,7 @@
     "oxfmt": "^0.42.0",
     "oxlint": "^1.57.0",
     "oxlint-tsgolint": "^0.18.1",
+    "preact": "^10.29.0",
     "react": ">=18",
     "react-dom": "^19.2.4",
     "tsdown": "^0.21.7",
@@ -47,6 +53,7 @@
     "vue": "^3.5.31"
   },
   "peerDependencies": {
+    "preact": ">=10",
     "react": ">=18",
     "vue": ">=3.4"
   },
@@ -54,6 +61,9 @@
     "react": {
       "optional": true
     },
+    "preact": {
+      "optional": true
+    },
     "vue": {
       "optional": true
     }