juststore 0.0.1

package/dist/mixed_state.js

@@ -0,0 +1,34 @@
+export { createMixedState };
+/**
+ * Creates a mixed state that combines multiple states into a tuple.
+ *
+ * If one of the states is changed, the mixed state will be updated.
+ *
+ * @param states - Array of states to combine
+ * @returns A new state that provides all values as a tuple
+ *
+ * @example
+ * const mixedState = createMixedState(states.addLoading, states.copyLoading, state.agent)
+ *
+ * <mixedState.Render>
+ *   {[addLoading, copyLoading, agent] => <SomeComponent />}
+ * </mixedState.Render>
+ */
+function createMixedState(...states) {
+    const use = () => states.map(state => state.use());
+    const mixedState = {
+        get value() {
+            return states.map(state => state.value);
+        },
+        use,
+        Render({ children }) {
+            const value = use();
+            return children(value);
+        },
+        Show({ children, on }) {
+            const value = use();
+            return on(value) ? children : null;
+        }
+    };
+    return mixedState;
+}

package/dist/node.d.ts

@@ -0,0 +1,11 @@
+import type { FieldValues } from './path';
+import type { State, StoreRoot } from './types';
+export { createNode, createRootNode, type Extension };
+/** Build a deep proxy for dynamic path access under a namespace. */
+declare function createRootNode<T extends FieldValues>(storeApi: StoreRoot<T>, initialPath?: string): State<T>;
+type Extension = {
+    get?: () => any;
+    set?: (value: any) => boolean;
+};
+declare function createNode<T extends FieldValues>(storeApi: StoreRoot<any>, path: string, cache: Map<string, any>, extensions?: Record<string | symbol, Extension>, from?: typeof unchanged, to?: typeof unchanged): State<T>;
+declare function unchanged(value: any): any;

package/dist/node.js

@@ -0,0 +1,218 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { useState } from 'react';
+export { createNode, createRootNode };
+/** Build a deep proxy for dynamic path access under a namespace. */
+function createRootNode(storeApi, initialPath = '') {
+    const proxyCache = new Map();
+    return createNode(storeApi, initialPath, proxyCache);
+}
+function createNode(storeApi, path, cache, extensions, from = unchanged, to = unchanged) {
+    const isDerived = from !== unchanged || to !== unchanged;
+    if (!isDerived && cache.has(path)) {
+        return cache.get(path);
+    }
+    const proxy = new Proxy({}, {
+        get(_target, prop) {
+            if (prop === 'field') {
+                return path.split('.').pop();
+            }
+            if (prop === 'use') {
+                return () => from(storeApi.use(path));
+            }
+            if (prop === 'useDebounce') {
+                return (delay) => from(storeApi.useDebounce(path, delay));
+            }
+            if (prop === 'useState') {
+                return () => [from(storeApi.use(path)), (value) => storeApi.set(path, to(value))];
+            }
+            if (prop === 'value') {
+                return from(storeApi.value(path));
+            }
+            if (prop === 'set') {
+                return (value, skipUpdate) => storeApi.set(path, to(value), skipUpdate);
+            }
+            if (prop === 'reset') {
+                return () => storeApi.reset(path);
+            }
+            if (prop === 'subscribe') {
+                return (listener) => storeApi.subscribe(path, value => listener(to(value)));
+            }
+            if (prop === 'Render') {
+                return ({ children }) => storeApi.Render({
+                    path,
+                    children: (value, update) => children(from(value), value => update(to(value)))
+                });
+            }
+            if (prop === 'Show') {
+                return ({ children, on }) => storeApi.Show({ path, children, on: value => on(from(value)) });
+            }
+            if (prop === 'compute') {
+                return (fn) => {
+                    const initialValue = from(storeApi.value(path));
+                    const [computedValue, setComputedValue] = useState(() => fn(initialValue));
+                    storeApi.subscribe(path, value => setComputedValue(fn(from(value))));
+                    return computedValue;
+                };
+            }
+            if (prop === 'derived') {
+                if (isDerived) {
+                    throw new Error('Derived method cannot be called on a derived node');
+                }
+                return ({ from, to }) => createNode(storeApi, path, cache, extensions, from, to);
+            }
+            if (Array.isArray(storeApi.value(path))) {
+                if (prop === 'at') {
+                    return (index) => {
+                        const nextPath = path ? `${path}.${index}` : String(index);
+                        return createNode(storeApi, nextPath, cache, extensions, from, to);
+                    };
+                }
+                if (prop === 'length') {
+                    const value = from(storeApi.value(path));
+                    return Array.isArray(value) ? value.length : undefined;
+                }
+                // Array mutation methods
+                if (prop === 'push') {
+                    return (...items) => {
+                        const currentArray = from(storeApi.value(path)) ?? [];
+                        const transformedItems = isDerived ? items.map(to) : items;
+                        const newArray = [...currentArray, ...transformedItems];
+                        storeApi.set(path, isDerived ? newArray.map(from) : newArray);
+                        return newArray.length;
+                    };
+                }
+                if (prop === 'pop') {
+                    return () => {
+                        const currentArray = from(storeApi.value(path)) ?? [];
+                        if (currentArray.length === 0)
+                            return undefined;
+                        const newArray = currentArray.slice(0, -1);
+                        const poppedItem = currentArray[currentArray.length - 1];
+                        storeApi.set(path, isDerived ? newArray.map(from) : newArray);
+                        return poppedItem;
+                    };
+                }
+                if (prop === 'shift') {
+                    return () => {
+                        const currentArray = from(storeApi.value(path)) ?? [];
+                        if (currentArray.length === 0)
+                            return undefined;
+                        const newArray = currentArray.slice(1);
+                        const shiftedItem = currentArray[0];
+                        storeApi.set(path, isDerived ? newArray.map(from) : newArray);
+                        return shiftedItem;
+                    };
+                }
+                if (prop === 'unshift') {
+                    return (...items) => {
+                        const currentArray = from(storeApi.value(path)) ?? [];
+                        const transformedItems = isDerived ? items.map(to) : items;
+                        const newArray = [...transformedItems, ...currentArray];
+                        storeApi.set(path, isDerived ? newArray.map(from) : newArray);
+                        return newArray.length;
+                    };
+                }
+                if (prop === 'splice') {
+                    return (start, deleteCount, ...items) => {
+                        const currentArray = from(storeApi.value(path)) ?? [];
+                        const newArray = [...currentArray];
+                        const transformedItems = isDerived ? items.map(to) : items;
+                        const deletedItems = newArray.splice(start, deleteCount ?? 0, ...transformedItems);
+                        storeApi.set(path, isDerived ? newArray.map(from) : newArray);
+                        return deletedItems;
+                    };
+                }
+                if (prop === 'reverse') {
+                    return () => {
+                        const currentArray = from(storeApi.value(path)) ?? [];
+                        if (!Array.isArray(currentArray))
+                            return [];
+                        const newArray = [...currentArray].reverse();
+                        storeApi.set(path, isDerived ? newArray.map(from) : newArray);
+                        return newArray;
+                    };
+                }
+                if (prop === 'sort') {
+                    return (compareFn) => {
+                        const currentArray = from(storeApi.value(path)) ?? [];
+                        const newArray = [...currentArray].sort(compareFn);
+                        storeApi.set(path, isDerived ? newArray.map(from) : newArray);
+                        return newArray;
+                    };
+                }
+                if (prop === 'fill') {
+                    return (value, start, end) => {
+                        const currentArray = from(storeApi.value(path)) ?? [];
+                        const newArray = [...currentArray].fill(value, start, end);
+                        storeApi.set(path, isDerived ? newArray.map(from) : newArray);
+                        return newArray;
+                    };
+                }
+                if (prop === 'copyWithin') {
+                    return (target, start, end) => {
+                        const currentArray = from(storeApi.value(path)) ?? [];
+                        const newArray = [...currentArray].copyWithin(target, start, end);
+                        storeApi.set(path, isDerived ? newArray.map(from) : newArray);
+                        return newArray;
+                    };
+                }
+                if (prop === 'sortedInsert') {
+                    return (cmp, ...items) => {
+                        const currentArray = from(storeApi.value(path)) ?? [];
+                        if (typeof cmp !== 'function')
+                            return isDerived ? currentArray.map(from).length : currentArray.length;
+                        // Create a copy of the current array
+                        const newArray = isDerived ? currentArray.map(from) : [...currentArray];
+                        const transformedItems = isDerived ? items.map(to) : items;
+                        // Insert each item in sorted order using binary search
+                        for (const item of transformedItems) {
+                            let left = 0;
+                            let right = newArray.length;
+                            // Binary search to find insertion point
+                            while (left < right) {
+                                const mid = (left + right) >>> 1;
+                                if (cmp(newArray[mid], item) <= 0) {
+                                    left = mid + 1;
+                                }
+                                else {
+                                    right = mid;
+                                }
+                            }
+                            // Insert at the found position
+                            newArray.splice(left, 0, item);
+                        }
+                        storeApi.set(path, isDerived ? newArray.map(from) : newArray);
+                        return newArray.length;
+                    };
+                }
+            }
+            if (extensions?.[prop]?.get) {
+                return extensions[prop]?.get();
+            }
+            if (typeof prop === 'string' || typeof prop === 'number') {
+                const nextPath = path ? `${path}.${prop}` : String(prop);
+                // Always return a proxy
+                return createNode(storeApi, nextPath, cache, extensions, from, to);
+            }
+            return undefined;
+        },
+        set(_target, prop, value) {
+            if (extensions?.[prop]?.set) {
+                return extensions[prop]?.set(value);
+            }
+            if (typeof prop === 'string' || typeof prop === 'number') {
+                const nextPath = path ? `${path}.${prop}` : prop;
+                storeApi.set(nextPath, to(value));
+                return true;
+            }
+            return false;
+        }
+    });
+    if (!isDerived) {
+        cache.set(path, proxy);
+    }
+    return proxy;
+}
+function unchanged(value) {
+    return value;
+}

package/dist/path.d.ts

@@ -0,0 +1,135 @@
+export type Primitive = null | undefined | string | number | boolean | symbol | bigint;
+export type BrowserNativeObject = Date | FileList | File;
+/**
+ * Type which given a tuple type returns its own keys, i.e. only its indices.
+ * @typeParam T - tuple type
+ * @example
+ * ```
+ * TupleKeys<[number, string]> = '0' | '1'
+ * ```
+ */
+export type TupleKeys<T extends ReadonlyArray<any>> = Exclude<keyof T, keyof any[]>;
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This actually constructs the strings and recurses into nested
+ * object types.
+ *
+ * See {@link ArrayPath}
+ */
+type ArrayPathImpl<K extends string | number, V, TraversedTypes> = V extends Primitive | BrowserNativeObject ? IsAny<V> extends true ? string : never : V extends ReadonlyArray<infer U> ? U extends Primitive | BrowserNativeObject ? IsAny<V> extends true ? string : never : true extends AnyIsEqual<TraversedTypes, V> ? never : `${K}` | `${K}.${ArrayPathInternal<V, TraversedTypes | V>}` : true extends AnyIsEqual<TraversedTypes, V> ? never : `${K}.${ArrayPathInternal<V, TraversedTypes | V>}`;
+/**
+ * Checks whether the type is any
+ * See {@link https://stackoverflow.com/a/49928360/3406963}
+ * @typeParam T - type which may be any
+ * ```
+ * IsAny<any> = true
+ * IsAny<string> = false
+ * ```
+ */
+export type IsAny<T> = 0 extends 1 & T ? true : false;
+/**
+ * Checks whether T1 can be exactly (mutually) assigned to T2
+ * @typeParam T1 - type to check
+ * @typeParam T2 - type to check against
+ * ```
+ * IsEqual<string, string> = true
+ * IsEqual<'foo', 'foo'> = true
+ * IsEqual<string, number> = false
+ * IsEqual<string, number> = false
+ * IsEqual<string, 'foo'> = false
+ * IsEqual<'foo', string> = false
+ * IsEqual<'foo' | 'bar', 'foo'> = boolean // 'foo' is assignable, but 'bar' is not (true | false) -> boolean
+ * ```
+ */
+export type IsEqual<T1, T2> = T1 extends T2 ? (<G>() => G extends T1 ? 1 : 2) extends <G>() => G extends T2 ? 1 : 2 ? true : false : false;
+/**
+ * Helper function to break apart T1 and check if any are equal to T2
+ *
+ * See {@link IsEqual}
+ */
+type AnyIsEqual<T1, T2> = T1 extends T2 ? (IsEqual<T1, T2> extends true ? true : never) : never;
+/**
+ * Type to query whether an array type T is a tuple type.
+ * @typeParam T - type which may be an array or tuple
+ * @example
+ * ```
+ * IsTuple<[number]> = true
+ * IsTuple<number[]> = false
+ * ```
+ */
+export type IsTuple<T extends ReadonlyArray<any>> = number extends T['length'] ? false : true;
+/**
+ * Type which can be used to index an array or tuple type.
+ */
+export type ArrayKey = number;
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This obscures the internal type param TraversedTypes from exported contract.
+ *
+ * See {@link ArrayPath}
+ */
+type ArrayPathInternal<T, TraversedTypes = T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
+    [K in TupleKeys<T>]-?: ArrayPathImpl<K & string, T[K], TraversedTypes>;
+}[TupleKeys<T>] : ArrayPathImpl<ArrayKey, V, TraversedTypes> : {
+    [K in keyof T]-?: ArrayPathImpl<K & string, T[K], TraversedTypes>;
+}[keyof T];
+/**
+ * Type which eagerly collects all paths through a type which point to an array
+ * type.
+ * @typeParam T - type which should be introspected.
+ * @example
+ * ```
+ * Path<{foo: {bar: string[], baz: number[]}}> = 'foo.bar' | 'foo.baz'
+ * ```
+ */
+export type ArrayPath<T> = T extends any ? ArrayPathInternal<T> : never;
+/**
+ * Type which eagerly collects all paths through a type
+ * @typeParam T - type which should be introspected
+ * @example
+ * ```
+ * Path<{foo: {bar: string}}> = 'foo' | 'foo.bar'
+ * ```
+ */
+export type Path<T> = T extends any ? PathInternal<T> : never;
+/**
+ * See {@link Path}
+ */
+export type FieldPath<TFieldValues extends FieldValues> = Path<TFieldValues>;
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This actually constructs the strings and recurses into nested
+ * object types.
+ *
+ * See {@link Path}
+ */
+type PathImpl<K extends string | number, V, TraversedTypes> = V extends Primitive | BrowserNativeObject ? `${K}` : true extends AnyIsEqual<TraversedTypes, V> ? `${K}` : `${K}` | `${K}.${PathInternal<V, TraversedTypes | V>}`;
+/**
+ * Helper type for recursively constructing paths through a type.
+ * This obscures the internal type param TraversedTypes from exported contract.
+ *
+ * See {@link Path}
+ */
+type PathInternal<T, TraversedTypes = T> = T extends ReadonlyArray<infer V> ? IsTuple<T> extends true ? {
+    [K in TupleKeys<T>]-?: PathImpl<K & string, T[K], TraversedTypes>;
+}[TupleKeys<T>] : PathImpl<ArrayKey, V, TraversedTypes> : {
+    [K in keyof T]-?: PathImpl<K & string, T[K], TraversedTypes>;
+}[keyof T];
+/**
+ * Type to evaluate the type which the given path points to.
+ * @typeParam T - deeply nested type which is indexed by the path
+ * @typeParam P - path into the deeply nested type
+ * @example
+ * ```
+ * PathValue<{foo: {bar: string}}, 'foo.bar'> = string
+ * PathValue<[number, string], '1'> = string
+ * ```
+ */
+export type PathValue<T, P extends Path<T> | ArrayPath<T>> = PathValueImpl<T, P>;
+type PathValueImpl<T, P extends string> = T extends any ? P extends `${infer K}.${infer R}` ? K extends keyof T ? undefined extends T[K] ? PathValueImpl<T[K], R> | undefined : PathValueImpl<T[K], R> : K extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? PathValueImpl<V, R> : never : never : P extends keyof T ? T[P] : P extends `${ArrayKey}` ? T extends ReadonlyArray<infer V> ? V : undefined extends T ? undefined : never : never : never;
+/**
+ * See {@link PathValue}
+ */
+export type FieldPathValue<TFieldValues extends FieldValues, TFieldPath extends FieldPath<TFieldValues>> = Exclude<PathValue<TFieldValues, TFieldPath>, Function>;
+export type FieldValues = Record<string, any>;
+export {};

package/dist/path.js

@@ -0,0 +1,2 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export {};

package/dist/root.d.ts

@@ -0,0 +1,7 @@
+import type { FieldValues } from './path';
+import type { StoreRoot } from './types';
+export { createStoreRoot, type StoreOptions };
+type StoreOptions = {
+    memoryOnly?: boolean;
+};
+declare function createStoreRoot<T extends FieldValues>(namespace: string, defaultValue: T, options?: StoreOptions): StoreRoot<T>;

package/dist/root.js

@@ -0,0 +1,63 @@
+import { useCallback, useRef } from 'react';
+import { getNestedValue, getSnapshot, joinPath, notifyListeners, produce, setLeaf, useDebounce, useObject, useSubscribe } from './impl';
+export { createStoreRoot };
+function createStoreRoot(namespace, defaultValue, options = {}) {
+    const memoryOnly = options?.memoryOnly ?? false;
+    if (memoryOnly) {
+        produce(namespace, undefined, true, false); // clear localStorage value
+    }
+    produce(namespace, { ...defaultValue, ...(getSnapshot(namespace) ?? {}) }, true, true);
+    const storeApi = {
+        use: (path) => useObject(namespace, path),
+        useDebounce: (path, delay) => useDebounce(namespace, path, delay),
+        set: (path, value, skipUpdate = false) => {
+            const currentValue = storeApi.value(path);
+            const newValue = typeof value === 'function'
+                ? value(currentValue)
+                : value;
+            return setLeaf(namespace, path, newValue, skipUpdate, memoryOnly);
+        },
+        value: (path) => getSnapshot(joinPath(namespace, path)),
+        reset: (path) => produce(joinPath(namespace, path), undefined, false, memoryOnly),
+        subscribe: (path, listener) => 
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        useSubscribe(joinPath(namespace, path), listener),
+        notify: (path) => {
+            const value = getNestedValue(getSnapshot(namespace), path);
+            return notifyListeners(joinPath(namespace, path), value, value, true, true);
+        },
+        useState: (path) => {
+            const fullPathRef = useRef(joinPath(namespace, path));
+            const setValue = useCallback((value) => {
+                if (typeof value === 'function') {
+                    const currentValue = getSnapshot(fullPathRef.current);
+                    const newValue = value(currentValue);
+                    return setLeaf(namespace, path, newValue, false, memoryOnly);
+                }
+                return setLeaf(namespace, path, value, false, memoryOnly);
+            }, [path]);
+            return [useObject(fullPathRef.current), setValue];
+        },
+        Render: ({ path, children }) => {
+            const fullPathRef = useRef(joinPath(namespace, path));
+            const value = useObject(fullPathRef.current);
+            const update = useCallback((value) => {
+                if (typeof value === 'function') {
+                    const currentValue = getSnapshot(fullPathRef.current);
+                    const newValue = value(currentValue);
+                    return setLeaf(namespace, path, newValue, false, memoryOnly);
+                }
+                return setLeaf(namespace, path, value, false, memoryOnly);
+            }, [path]);
+            return children(value, update);
+        },
+        Show: ({ path, children, on }) => {
+            const value = useObject(namespace, path);
+            if (!on(value)) {
+                return null;
+            }
+            return children;
+        }
+    };
+    return storeApi;
+}

package/dist/store.d.ts

@@ -0,0 +1,19 @@
+import type { FieldValues } from './path';
+import { type StoreOptions } from './root';
+import type { DeepProxy, State, StoreRoot } from './types';
+export { createStore, type Store };
+/**
+ * A persistent, hierarchical, cross-tab synchronized key-value store with React bindings.
+ *
+ * - Dot-path addressing for nested values (e.g. "config.ui.theme").
+ * - Immutable partial updates with automatic object/array creation.
+ * - Persists root namespaces to localStorage with an in-memory mirror (no localStorage on SSR).
+ * - Cross-tab synchronization via BroadcastChannel (no-ops on SSR).
+ * - Fine-grained subscriptions built on useSyncExternalStore.
+ * - Type-safe paths using FieldPath.
+ * - Dynamic deep access via Proxy for ergonomic usage like `store.a.b.c.use()` and `store.a.b.c.set(v)`.
+ */
+type Store<T extends FieldValues> = StoreRoot<T> & {
+    [K in keyof T]: NonNullable<T[K]> extends object ? DeepProxy<T[K]> : State<T[K]>;
+};
+declare function createStore<T extends FieldValues>(namespace: string, defaultValue: T, options?: StoreOptions): Store<T>;

package/dist/store.js

@@ -0,0 +1,17 @@
+import { createRootNode } from './node';
+import { createStoreRoot } from './root';
+export { createStore };
+function createStore(namespace, defaultValue, options = {}) {
+    const storeApi = createStoreRoot(namespace, defaultValue, options);
+    return new Proxy(storeApi, {
+        get(target, prop) {
+            if (prop in target) {
+                return target[prop];
+            }
+            if (typeof prop === 'string' || typeof prop === 'number') {
+                return createRootNode(target, prop);
+            }
+            return undefined;
+        }
+    });
+}

package/dist/types.d.ts

@@ -0,0 +1,118 @@
+import type { FieldPath, FieldPathValue, FieldValues } from './path';
+export type { ArrayProxy, DeepProxy, DerivedStateProps, Prettify, State, StoreRenderProps, StoreRoot, StoreSetStateAction, StoreShowProps, StoreUse };
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/** Type for nested objects with proxy methods */
+type DeepProxy<T> = NonNullable<T> extends readonly (infer U)[] ? ArrayProxy<U> & State<T> : NonNullable<T> extends FieldValues ? {
+    [K in keyof NonNullable<T>]-?: NonNullable<NonNullable<T>[K]> extends object ? DeepProxy<NonNullable<T>[K]> : State<NonNullable<T>[K]>;
+} & State<T> : State<T>;
+type ArrayMutationMethods<T> = Pick<Array<T>, 'push' | 'pop' | 'shift' | 'unshift' | 'splice' | 'reverse' | 'sort' | 'fill' | 'copyWithin'>;
+/** Type for array proxy with index access */
+type ArrayProxy<T> = Prettify<ArrayMutationMethods<T>> & {
+    /** Read without subscribing. Returns array or undefined for missing paths. */
+    readonly value: T[] | undefined;
+    /**
+     * Length of the underlying array. Runtime may return undefined when the
+     * current value is not an array at the path. Prefer `Array.isArray(x) && x.length` when unsure.
+     */
+    readonly length: number;
+    /** Numeric index access never returns undefined at the type level because
+     * the proxy always returns another proxy object, even if the underlying value doesn't exist.
+     */
+    [K: number]: T extends object ? DeepProxy<T> : State<T>;
+    /** Safe accessor that never returns undefined at the type level */
+    at(index: number): T extends object ? DeepProxy<T> : State<T>;
+    /** Insert items into the array in sorted order using the provided comparison function. */
+    sortedInsert(cmp: (a: T, b: T) => number, ...items: T[]): number;
+};
+/** Tuple returned by Store.use(path). */
+type StoreUse<T> = Readonly<[T | undefined, (value: T | undefined) => void]>;
+type StoreSetStateAction<T> = (value: T | undefined | ((prev: T) => T), skipUpdate?: boolean) => void;
+/** Public API returned by createStore(namespace, defaultValue). */
+type StoreRoot<T extends FieldValues> = {
+    /** Subscribe and read the value at path. Re-renders when the value changes. */
+    use: <P extends FieldPath<T>>(path: P) => FieldPathValue<T, P> | undefined;
+    /** Subscribe and read the debounced value at path. Re-renders when the value changes. */
+    useDebounce: <P extends FieldPath<T>>(path: P, delay: number) => FieldPathValue<T, P> | undefined;
+    /** Set value at path (creates intermediate nodes as needed). */
+    set: <P extends FieldPath<T>>(path: P, value: FieldPathValue<T, P> | ((prev: FieldPathValue<T, P> | undefined) => FieldPathValue<T, P>), skipUpdate?: boolean) => void;
+    /** Read without subscribing. */
+    value: <P extends FieldPath<T>>(path: P) => FieldPathValue<T, P> | undefined;
+    /** Delete value at path (for arrays, removes index; for objects, deletes key). */
+    reset: <P extends FieldPath<T>>(path: P) => void;
+    /** Subscribe to changes at path and invoke listener with the new value. */
+    subscribe: <P extends FieldPath<T>>(path: P, listener: (value: FieldPathValue<T, P>) => void) => void;
+    /** Notify listeners at path. */
+    notify: <P extends FieldPath<T>>(path: P) => void;
+    /** Convenience hook returning [value, setValue] for the path. */
+    useState: <P extends FieldPath<T>>(path: P) => StoreUse<FieldPathValue<T, P>>;
+    /** Render-prop helper for inline usage. */
+    Render: <P extends FieldPath<T>>(props: FieldPathValue<T, P> extends undefined ? never : StoreRenderProps<T, P>) => React.ReactNode;
+    /** Show or hide children based on the value at the path. */
+    Show: <P extends FieldPath<T>>(props: FieldPathValue<T, P> extends undefined ? never : StoreShowProps<T, P>) => React.ReactNode;
+};
+/** Common methods available on any deep proxy node */
+type State<T> = {
+    /** Read without subscribing. */
+    readonly value: T;
+    /** The field name for the proxy. */
+    readonly field: string;
+    /** Subscribe and read the value at path. Re-renders when the value changes. */
+    use(): T;
+    /** Subscribe and read the debounced value at path. Re-renders when the value changes. */
+    useDebounce(delay: number): T;
+    /** Convenience hook returning [value, setValue] for the path. */
+    useState(): readonly [T, (value: T | undefined) => void];
+    /** Set value at path (creates intermediate nodes as needed). */
+    set(value: T | undefined | ((prev: T) => T), skipUpdate?: boolean): void;
+    /** Delete value at path (for arrays, removes index; for objects, deletes key). */
+    reset(): void;
+    /** Subscribe to changes at path and invoke listener with the new value. */
+    subscribe(listener: (value: T) => void): void;
+    /** Compute a derived value from the current value, similar to useState + useMemo */
+    compute: <R>(fn: (value: T) => R) => R;
+    /** Virtual state derived from the current value. */
+    derived: <R>({ from, to }: {
+        from: (value: T | undefined) => R;
+        to: (value: R) => T | undefined;
+    }) => State<R>;
+    /** Notify listener of current value. */
+    notify(): void;
+    /** Render-prop helper for inline usage.
+     *
+     * @example
+     * <store.a.b.c.Render>
+     *   {(value, update) => <button onClick={() => update('new value')}>{value}</button>}
+     * </store.a.b.c.Render>
+     */
+    Render: (props: {
+        children: (value: T, update: (value: T | undefined) => void) => React.ReactNode;
+    }) => React.ReactNode;
+    /** Show or hide children based on the value at the path.
+     *
+     * @example
+     * <store.a.b.c.Show on={value => value === 'show'}>
+     *   <div>Show</div>
+     * </store.a.b.c.Show>
+     */
+    Show: (props: {
+        children: React.ReactNode;
+        on: (value: T) => boolean;
+    }) => React.ReactNode;
+};
+/** Props for Store.Render helper. */
+type StoreRenderProps<T extends FieldValues, P extends FieldPath<T>> = {
+    path: P;
+    children: (value: FieldPathValue<T, P> | undefined, update: (value: FieldPathValue<T, P> | undefined) => void) => React.ReactNode;
+};
+/** Props for Store.Show helper. */
+type StoreShowProps<T extends FieldValues, P extends FieldPath<T>> = {
+    path: P;
+    children: React.ReactNode;
+    on: (value: FieldPathValue<T, P> | undefined) => boolean;
+};
+type DerivedStateProps<T, R> = {
+    from: (value: T | undefined) => R;
+    to: (value: R) => T | undefined;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};