@graphrefly/graphrefly 0.45.0 → 0.46.0

package/dist/index-B6pxYJzO.d.cts

@@ -0,0 +1,36 @@
+import { Node } from '@graphrefly/pure-ts/core';
+
+/** Solid accessor function — returns current value when called. */
+type Accessor<T> = () => T;
+/**
+ * Subscribe to a `Node<T>` as a Solid signal. Auto-cleans up with the owning scope.
+ * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
+ */
+declare function useSubscribe<T>(node: Node<T>): Accessor<T | undefined | null>;
+/**
+ * Bind a writable `Node<T>` as a Solid resource tuple `[accessor, setter]`.
+ * Setter always forwards `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
+ */
+declare function useStore<T>(node: Node<T>): [Accessor<T | undefined | null>, (v: T) => void];
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
+type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic set of keyed node records as a Solid accessor.
+ * Re-subscribes all per-key fields whenever `keys` changes.
+ * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
+ */
+declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory<K, R>): Accessor<Record<K, R>>;
+
+type index_Accessor<T> = Accessor<T>;
+type index_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
+declare const index_useStore: typeof useStore;
+declare const index_useSubscribe: typeof useSubscribe;
+declare const index_useSubscribeRecord: typeof useSubscribeRecord;
+declare namespace index {
+  export { type index_Accessor as Accessor, type index_NodeFactory as NodeFactory, index_useStore as useStore, index_useSubscribe as useSubscribe, index_useSubscribeRecord as useSubscribeRecord };
+}
+
+export { type Accessor as A, type NodeFactory as N, useSubscribe as a, useSubscribeRecord as b, index as i, useStore as u };

package/dist/index-B6pxYJzO.d.ts

@@ -0,0 +1,36 @@
+import { Node } from '@graphrefly/pure-ts/core';
+
+/** Solid accessor function — returns current value when called. */
+type Accessor<T> = () => T;
+/**
+ * Subscribe to a `Node<T>` as a Solid signal. Auto-cleans up with the owning scope.
+ * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
+ */
+declare function useSubscribe<T>(node: Node<T>): Accessor<T | undefined | null>;
+/**
+ * Bind a writable `Node<T>` as a Solid resource tuple `[accessor, setter]`.
+ * Setter always forwards `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to Solid scope cleanup (not node terminal messages).
+ */
+declare function useStore<T>(node: Node<T>): [Accessor<T | undefined | null>, (v: T) => void];
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
+type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic set of keyed node records as a Solid accessor.
+ * Re-subscribes all per-key fields whenever `keys` changes.
+ * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
+ */
+declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory<K, R>): Accessor<Record<K, R>>;
+
+type index_Accessor<T> = Accessor<T>;
+type index_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
+declare const index_useStore: typeof useStore;
+declare const index_useSubscribe: typeof useSubscribe;
+declare const index_useSubscribeRecord: typeof useSubscribeRecord;
+declare namespace index {
+  export { type index_Accessor as Accessor, type index_NodeFactory as NodeFactory, index_useStore as useStore, index_useSubscribe as useSubscribe, index_useSubscribeRecord as useSubscribeRecord };
+}
+
+export { type Accessor as A, type NodeFactory as N, useSubscribe as a, useSubscribeRecord as b, index as i, useStore as u };

package/dist/index-BFsng6v1.d.cts

@@ -0,0 +1,44 @@
+import { Node } from '@graphrefly/pure-ts/core';
+
+/**
+ * Subscribe to a read-only `Node<T>` as a React value. Re-renders on node value settlement.
+ * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
+ *
+ * @param node - Any `Node<T>`.
+ * @returns `T | undefined` — the current node value, kept in sync via `useSyncExternalStore`.
+ */
+declare function useSubscribe<T>(node: Node<T>): T | undefined | null;
+/**
+ * Bind a writable `Node<T>` as a React `[value, setter]` tuple.
+ * Setting the value always pushes `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
+ *
+ * @param node - A `Node<T>` (e.g. state node).
+ * @returns `[T | undefined, (value: T) => void]` — current value and setter function.
+ */
+declare function useStore<T>(node: Node<T>): [T | undefined | null, (value: T) => void];
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
+type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic set of keyed node records.
+ * Re-subscribes all per-key fields whenever `keysNode` changes.
+ * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
+ * Guaranteed to clean up strictly with React hook lifecycle, utilizing no global mappings.
+ *
+ * @param keysNode - Node of current keys (e.g. node IDs)
+ * @param factory - Function returning `{ [field]: Node<V> }` for each key.
+ * @returns `Record<K, R>` — snapshot of resolved values for all keys.
+ */
+declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory<K, R>): Record<K, R>;
+
+type index_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
+declare const index_useStore: typeof useStore;
+declare const index_useSubscribe: typeof useSubscribe;
+declare const index_useSubscribeRecord: typeof useSubscribeRecord;
+declare namespace index {
+  export { type index_NodeFactory as NodeFactory, index_useStore as useStore, index_useSubscribe as useSubscribe, index_useSubscribeRecord as useSubscribeRecord };
+}
+
+export { type NodeFactory as N, useSubscribe as a, useSubscribeRecord as b, index as i, useStore as u };

package/dist/index-BFsng6v1.d.ts

@@ -0,0 +1,44 @@
+import { Node } from '@graphrefly/pure-ts/core';
+
+/**
+ * Subscribe to a read-only `Node<T>` as a React value. Re-renders on node value settlement.
+ * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
+ *
+ * @param node - Any `Node<T>`.
+ * @returns `T | undefined` — the current node value, kept in sync via `useSyncExternalStore`.
+ */
+declare function useSubscribe<T>(node: Node<T>): T | undefined | null;
+/**
+ * Bind a writable `Node<T>` as a React `[value, setter]` tuple.
+ * Setting the value always pushes `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to React mount/unmount (not node terminal messages).
+ *
+ * @param node - A `Node<T>` (e.g. state node).
+ * @returns `[T | undefined, (value: T) => void]` — current value and setter function.
+ */
+declare function useStore<T>(node: Node<T>): [T | undefined | null, (value: T) => void];
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
+type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic set of keyed node records.
+ * Re-subscribes all per-key fields whenever `keysNode` changes.
+ * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
+ * Guaranteed to clean up strictly with React hook lifecycle, utilizing no global mappings.
+ *
+ * @param keysNode - Node of current keys (e.g. node IDs)
+ * @param factory - Function returning `{ [field]: Node<V> }` for each key.
+ * @returns `Record<K, R>` — snapshot of resolved values for all keys.
+ */
+declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory<K, R>): Record<K, R>;
+
+type index_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
+declare const index_useStore: typeof useStore;
+declare const index_useSubscribe: typeof useSubscribe;
+declare const index_useSubscribeRecord: typeof useSubscribeRecord;
+declare namespace index {
+  export { type index_NodeFactory as NodeFactory, index_useStore as useStore, index_useSubscribe as useSubscribe, index_useSubscribeRecord as useSubscribeRecord };
+}
+
+export { type NodeFactory as N, useSubscribe as a, useSubscribeRecord as b, index as i, useStore as u };

package/dist/index-Bg-LwEt-.d.cts

@@ -0,0 +1,45 @@
+import { Node } from '@graphrefly/pure-ts/core';
+
+/** Svelte store contract — implements the minimal `subscribe` method. */
+interface SvelteReadable<T> {
+    subscribe(run: (value: T) => void): () => void;
+}
+/** Svelte writable store contract. */
+interface SvelteWritable<T> extends SvelteReadable<T> {
+    set(value: T): void;
+    update(updater: (value: T) => T): void;
+}
+/**
+ * Subscribe to a `Node<T>` as a Svelte readable store (implements Svelte store contract).
+ * Subscription lifecycle is tied to Svelte store unsubscription (not node terminal messages).
+ */
+declare function useSubscribe<T>(node: Node<T>): SvelteReadable<T | undefined | null>;
+/**
+ * Bind a writable `Node<T>` as a Svelte writable store.
+ * Reads and writes adapt seamlessly.
+ * Setter/update always forward `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to Svelte store unsubscription (not node terminal messages).
+ */
+declare function useStore<T>(node: Node<T>): SvelteWritable<T | undefined | null>;
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
+type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic keyed record of nodes as a Svelte readable store.
+ * Re-subscribes all per-key fields whenever `keysNode` changes.
+ * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
+ */
+declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory<K, R>): SvelteReadable<Record<K, R>>;
+
+type index_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
+type index_SvelteReadable<T> = SvelteReadable<T>;
+type index_SvelteWritable<T> = SvelteWritable<T>;
+declare const index_useStore: typeof useStore;
+declare const index_useSubscribe: typeof useSubscribe;
+declare const index_useSubscribeRecord: typeof useSubscribeRecord;
+declare namespace index {
+  export { type index_NodeFactory as NodeFactory, type index_SvelteReadable as SvelteReadable, type index_SvelteWritable as SvelteWritable, index_useStore as useStore, index_useSubscribe as useSubscribe, index_useSubscribeRecord as useSubscribeRecord };
+}
+
+export { type NodeFactory as N, type SvelteReadable as S, type SvelteWritable as a, useSubscribe as b, useSubscribeRecord as c, index as i, useStore as u };

package/dist/index-Bg-LwEt-.d.ts

@@ -0,0 +1,45 @@
+import { Node } from '@graphrefly/pure-ts/core';
+
+/** Svelte store contract — implements the minimal `subscribe` method. */
+interface SvelteReadable<T> {
+    subscribe(run: (value: T) => void): () => void;
+}
+/** Svelte writable store contract. */
+interface SvelteWritable<T> extends SvelteReadable<T> {
+    set(value: T): void;
+    update(updater: (value: T) => T): void;
+}
+/**
+ * Subscribe to a `Node<T>` as a Svelte readable store (implements Svelte store contract).
+ * Subscription lifecycle is tied to Svelte store unsubscription (not node terminal messages).
+ */
+declare function useSubscribe<T>(node: Node<T>): SvelteReadable<T | undefined | null>;
+/**
+ * Bind a writable `Node<T>` as a Svelte writable store.
+ * Reads and writes adapt seamlessly.
+ * Setter/update always forward `[[DIRTY], [DATA, value]]`, including `value === undefined`.
+ * Subscription lifecycle is tied to Svelte store unsubscription (not node terminal messages).
+ */
+declare function useStore<T>(node: Node<T>): SvelteWritable<T | undefined | null>;
+/** Maps a key to an object of nodes. Used by `useSubscribeRecord`. */
+type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
+    [P in keyof R]: Node<R[P]>;
+};
+/**
+ * Subscribe to a dynamic keyed record of nodes as a Svelte readable store.
+ * Re-subscribes all per-key fields whenever `keysNode` changes.
+ * Key re-sync is gated to settled batches (`messageTier >= 3`) to avoid DIRTY-phase churn.
+ */
+declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory<K, R>): SvelteReadable<Record<K, R>>;
+
+type index_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
+type index_SvelteReadable<T> = SvelteReadable<T>;
+type index_SvelteWritable<T> = SvelteWritable<T>;
+declare const index_useStore: typeof useStore;
+declare const index_useSubscribe: typeof useSubscribe;
+declare const index_useSubscribeRecord: typeof useSubscribeRecord;
+declare namespace index {
+  export { type index_NodeFactory as NodeFactory, type index_SvelteReadable as SvelteReadable, type index_SvelteWritable as SvelteWritable, index_useStore as useStore, index_useSubscribe as useSubscribe, index_useSubscribeRecord as useSubscribeRecord };
+}
+
+export { type NodeFactory as N, type SvelteReadable as S, type SvelteWritable as a, useSubscribe as b, useSubscribeRecord as c, index as i, useStore as u };

package/dist/index-Brp888t0.d.cts

@@ -0,0 +1,127 @@
+import { Node } from '@graphrefly/pure-ts/core';
+
+/**
+ * A Nanostores-compatible atom.
+ *
+ * @category compat
+ */
+interface NanoAtom<T> {
+    /** Get current value. */
+    get(): T;
+    /** Set a new value (writable atoms only). */
+    set(value: T): void;
+    /** Subscribe to value changes. Callback receives the new value.
+     * Returns unsubscribe function. Called immediately with current value. */
+    subscribe(cb: (value: T) => void): () => void;
+    /** Listen to value changes (no immediate call). Returns unsubscribe. */
+    listen(cb: (value: T) => void): () => void;
+    /** The underlying GraphReFly node. */
+    readonly _node: Node<T>;
+}
+/**
+ * A Nanostores-compatible computed store.
+ *
+ * @category compat
+ */
+interface NanoComputed<T> {
+    /** Get current value. */
+    get(): T;
+    /** Subscribe to value changes. Called immediately with current value.
+     * Returns unsubscribe function. */
+    subscribe(cb: (value: T) => void): () => void;
+    /** Listen to value changes (no immediate call). Returns unsubscribe. */
+    listen(cb: (value: T) => void): () => void;
+    /** The underlying GraphReFly node. */
+    readonly _node: Node<T>;
+}
+/**
+ * A Nanostores-compatible map.
+ *
+ * @category compat
+ */
+interface NanoMap<T extends Record<string, unknown>> extends NanoAtom<T> {
+    /** Set a single key. */
+    setKey<K extends keyof T>(key: K, value: T[K]): void;
+}
+/**
+ * Creates a nanostores-compatible atom.
+ *
+ * @param initial - Initial value.
+ * @returns `NanoAtom<T>`
+ *
+ * @category compat
+ */
+declare function atom<T>(initial: T): NanoAtom<T>;
+/**
+ * Creates a nanostores-compatible computed store.
+ *
+ * @param stores - One or more atoms/computed stores.
+ * @param fn - Compute function.
+ * @returns `NanoComputed<T>`
+ *
+ * @category compat
+ */
+declare function computed<T, A>(storeA: NanoAtom<A> | NanoComputed<A>, fn: (a: A) => T): NanoComputed<T>;
+declare function computed<T, A, B>(stores: [NanoAtom<A> | NanoComputed<A>, NanoAtom<B> | NanoComputed<B>], fn: (a: A, b: B) => T): NanoComputed<T>;
+declare function computed<T, A, B, C>(stores: [
+    NanoAtom<A> | NanoComputed<A>,
+    NanoAtom<B> | NanoComputed<B>,
+    NanoAtom<C> | NanoComputed<C>
+], fn: (a: A, b: B, c: C) => T): NanoComputed<T>;
+/**
+ * Creates a nanostores-compatible map.
+ *
+ * @param initial - Initial object value.
+ * @returns `NanoMap<T>`
+ *
+ * @category compat
+ */
+declare function map<T extends Record<string, unknown>>(initial: T): NanoMap<T>;
+/**
+ * Returns the current value of the store.
+ *
+ * @category compat
+ */
+declare function getValue<T>(store: NanoAtom<T> | NanoComputed<T>): T;
+/**
+ * Adds a listener for the store start (first listener connected).
+ *
+ * @category compat
+ */
+declare function onStart(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void;
+/**
+ * Adds a listener for the store stop (last listener disconnected).
+ *
+ * @category compat
+ */
+declare function onStop(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void;
+/**
+ * Adds a listener for the store mount (first listener connected).
+ *
+ * @returns A cleanup function called when the last listener is removed.
+ * @category compat
+ */
+declare function onMount(store: NanoAtom<any> | NanoComputed<any>, cb: () => (() => void) | undefined): void;
+/**
+ * Batches multiple store updates.
+ *
+ * @category compat
+ */
+declare function action<Args extends any[], Return>(_store: NanoAtom<any> | NanoComputed<any>, _name: string, fn: (...args: Args) => Return): (...args: Args) => Return;
+
+type index_NanoAtom<T> = NanoAtom<T>;
+type index_NanoComputed<T> = NanoComputed<T>;
+type index_NanoMap<T extends Record<string, unknown>> = NanoMap<T>;
+declare const index_action: typeof action;
+declare const index_atom: typeof atom;
+declare const index_computed: typeof computed;
+declare const index_getValue: typeof getValue;
+declare const index_map: typeof map;
+declare const index_onMount: typeof onMount;
+declare const index_onStart: typeof onStart;
+declare const index_onStop: typeof onStop;
+declare namespace index {
+  export { type index_NanoAtom as NanoAtom, type index_NanoComputed as NanoComputed, type index_NanoMap as NanoMap, index_action as action, index_atom as atom, index_computed as computed, index_getValue as getValue, index_map as map, index_onMount as onMount, index_onStart as onStart, index_onStop as onStop };
+}
+
+export { type NanoAtom as N, type NanoComputed as a, type NanoMap as b, action as c, atom as d, computed as e, onStart as f, getValue as g, onStop as h, index as i, map as m, onMount as o };

package/dist/index-Brp888t0.d.ts

@@ -0,0 +1,127 @@
+import { Node } from '@graphrefly/pure-ts/core';
+
+/**
+ * A Nanostores-compatible atom.
+ *
+ * @category compat
+ */
+interface NanoAtom<T> {
+    /** Get current value. */
+    get(): T;
+    /** Set a new value (writable atoms only). */
+    set(value: T): void;
+    /** Subscribe to value changes. Callback receives the new value.
+     * Returns unsubscribe function. Called immediately with current value. */
+    subscribe(cb: (value: T) => void): () => void;
+    /** Listen to value changes (no immediate call). Returns unsubscribe. */
+    listen(cb: (value: T) => void): () => void;
+    /** The underlying GraphReFly node. */
+    readonly _node: Node<T>;
+}
+/**
+ * A Nanostores-compatible computed store.
+ *
+ * @category compat
+ */
+interface NanoComputed<T> {
+    /** Get current value. */
+    get(): T;
+    /** Subscribe to value changes. Called immediately with current value.
+     * Returns unsubscribe function. */
+    subscribe(cb: (value: T) => void): () => void;
+    /** Listen to value changes (no immediate call). Returns unsubscribe. */
+    listen(cb: (value: T) => void): () => void;
+    /** The underlying GraphReFly node. */
+    readonly _node: Node<T>;
+}
+/**
+ * A Nanostores-compatible map.
+ *
+ * @category compat
+ */
+interface NanoMap<T extends Record<string, unknown>> extends NanoAtom<T> {
+    /** Set a single key. */
+    setKey<K extends keyof T>(key: K, value: T[K]): void;
+}
+/**
+ * Creates a nanostores-compatible atom.
+ *
+ * @param initial - Initial value.
+ * @returns `NanoAtom<T>`
+ *
+ * @category compat
+ */
+declare function atom<T>(initial: T): NanoAtom<T>;
+/**
+ * Creates a nanostores-compatible computed store.
+ *
+ * @param stores - One or more atoms/computed stores.
+ * @param fn - Compute function.
+ * @returns `NanoComputed<T>`
+ *
+ * @category compat
+ */
+declare function computed<T, A>(storeA: NanoAtom<A> | NanoComputed<A>, fn: (a: A) => T): NanoComputed<T>;
+declare function computed<T, A, B>(stores: [NanoAtom<A> | NanoComputed<A>, NanoAtom<B> | NanoComputed<B>], fn: (a: A, b: B) => T): NanoComputed<T>;
+declare function computed<T, A, B, C>(stores: [
+    NanoAtom<A> | NanoComputed<A>,
+    NanoAtom<B> | NanoComputed<B>,
+    NanoAtom<C> | NanoComputed<C>
+], fn: (a: A, b: B, c: C) => T): NanoComputed<T>;
+/**
+ * Creates a nanostores-compatible map.
+ *
+ * @param initial - Initial object value.
+ * @returns `NanoMap<T>`
+ *
+ * @category compat
+ */
+declare function map<T extends Record<string, unknown>>(initial: T): NanoMap<T>;
+/**
+ * Returns the current value of the store.
+ *
+ * @category compat
+ */
+declare function getValue<T>(store: NanoAtom<T> | NanoComputed<T>): T;
+/**
+ * Adds a listener for the store start (first listener connected).
+ *
+ * @category compat
+ */
+declare function onStart(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void;
+/**
+ * Adds a listener for the store stop (last listener disconnected).
+ *
+ * @category compat
+ */
+declare function onStop(store: NanoAtom<any> | NanoComputed<any>, cb: () => void): void;
+/**
+ * Adds a listener for the store mount (first listener connected).
+ *
+ * @returns A cleanup function called when the last listener is removed.
+ * @category compat
+ */
+declare function onMount(store: NanoAtom<any> | NanoComputed<any>, cb: () => (() => void) | undefined): void;
+/**
+ * Batches multiple store updates.
+ *
+ * @category compat
+ */
+declare function action<Args extends any[], Return>(_store: NanoAtom<any> | NanoComputed<any>, _name: string, fn: (...args: Args) => Return): (...args: Args) => Return;
+
+type index_NanoAtom<T> = NanoAtom<T>;
+type index_NanoComputed<T> = NanoComputed<T>;
+type index_NanoMap<T extends Record<string, unknown>> = NanoMap<T>;
+declare const index_action: typeof action;
+declare const index_atom: typeof atom;
+declare const index_computed: typeof computed;
+declare const index_getValue: typeof getValue;
+declare const index_map: typeof map;
+declare const index_onMount: typeof onMount;
+declare const index_onStart: typeof onStart;
+declare const index_onStop: typeof onStop;
+declare namespace index {
+  export { type index_NanoAtom as NanoAtom, type index_NanoComputed as NanoComputed, type index_NanoMap as NanoMap, index_action as action, index_atom as atom, index_computed as computed, index_getValue as getValue, index_map as map, index_onMount as onMount, index_onStart as onStart, index_onStop as onStop };
+}
+
+export { type NanoAtom as N, type NanoComputed as a, type NanoMap as b, action as c, atom as d, computed as e, onStart as f, getValue as g, onStop as h, index as i, map as m, onMount as o };

package/dist/index-CDfk6jHN.d.cts

@@ -0,0 +1,37 @@
+import { Graph } from '@graphrefly/pure-ts/graph';
+
+/** Zustand-compatible Store API. */
+interface StoreApi<T> {
+    getState: () => T;
+    setState: (partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: boolean) => void;
+    getInitialState: () => T;
+    subscribe: (listener: (state: T, prevState: T) => void) => () => void;
+    destroy: () => void;
+}
+/** Function type for initializing the store. */
+type StateCreator<T> = (set: StoreApi<T>["setState"], get: StoreApi<T>["getState"], api: StoreApi<T>) => T;
+/**
+ * Creates a Zustand-compatible store backed by a GraphReFly state node.
+ * returns an object that is both a Graph and a StoreApi.
+ *
+ * @example
+ * ```ts
+ * const store = create((set) => ({
+ *   count: 0,
+ *   inc: () => set((s) => ({ count: s.count + 1 }))
+ * }));
+ * store.getState().inc();
+ * ```
+ *
+ * @category compat
+ */
+declare function create<T extends object>(initializer: StateCreator<T>): Graph & StoreApi<T>;
+
+type index_StateCreator<T> = StateCreator<T>;
+type index_StoreApi<T> = StoreApi<T>;
+declare const index_create: typeof create;
+declare namespace index {
+  export { type index_StateCreator as StateCreator, type index_StoreApi as StoreApi, index_create as create };
+}
+
+export { type StateCreator as S, type StoreApi as a, create as c, index as i };

package/dist/index-CDfk6jHN.d.ts

@@ -0,0 +1,37 @@
+import { Graph } from '@graphrefly/pure-ts/graph';
+
+/** Zustand-compatible Store API. */
+interface StoreApi<T> {
+    getState: () => T;
+    setState: (partial: T | Partial<T> | ((state: T) => T | Partial<T>), replace?: boolean) => void;
+    getInitialState: () => T;
+    subscribe: (listener: (state: T, prevState: T) => void) => () => void;
+    destroy: () => void;
+}
+/** Function type for initializing the store. */
+type StateCreator<T> = (set: StoreApi<T>["setState"], get: StoreApi<T>["getState"], api: StoreApi<T>) => T;
+/**
+ * Creates a Zustand-compatible store backed by a GraphReFly state node.
+ * returns an object that is both a Graph and a StoreApi.
+ *
+ * @example
+ * ```ts
+ * const store = create((set) => ({
+ *   count: 0,
+ *   inc: () => set((s) => ({ count: s.count + 1 }))
+ * }));
+ * store.getState().inc();
+ * ```
+ *
+ * @category compat
+ */
+declare function create<T extends object>(initializer: StateCreator<T>): Graph & StoreApi<T>;
+
+type index_StateCreator<T> = StateCreator<T>;
+type index_StoreApi<T> = StoreApi<T>;
+declare const index_create: typeof create;
+declare namespace index {
+  export { type index_StateCreator as StateCreator, type index_StoreApi as StoreApi, index_create as create };
+}
+
+export { type StateCreator as S, type StoreApi as a, create as c, index as i };