@aihu/reactive

function isReactive(value: unknown): boolean

True for a proxy produced by `reactive()`.

function mutate<T extends object>(target: T, recipe: (draft: T) => void): void

Apply many writes as ONE flush.

function reactive<T extends object>(source: T): T

Wrap a plain object/array in a fine-grained reactive tree.

function reactiveComputed<T extends object>(fn: () => T): T

A reactive object kept in sync with `fn()` by an effect + `reconcile`.

function reactiveOmit<T extends object, K extends keyof T>(s: T, ...keys: K[]): Omit<T, K>

Read-through view omitting a subset of keys — no copies, tracking is preserved.

function reactivePick<T extends object, K extends keyof T>(s: T, ...keys: K[]): Pick<T, K>

Read-through view over a subset of keys — no copies, tracking is preserved (each read forwards to the source proxy's own trap).

function reconcile<T extends object>(target: T, next: T, options?: ReconcileOptions): void

Merge `next` into `target` in place, preserving node identity for unchanged values and notifying ONLY changed paths.

function toReactive<T extends object>(source: Signal<T>): T

Signal-of-object → reactive-looking view.

function toSignal<T extends object, K extends keyof T>(t: T, k: K): Signal<T[K]>

Lens a single property as a signal tuple — the tree → tuple bridge.

function toSignals<T extends object>(t: T): { [K in keyof T]: Signal<T[K]> }

Every own key as a signal tuple.

function unwrap<T>(value: T): T

The raw object behind a reactive proxy (O(1), no traversal — writes unwrap, so the raw tree never contains proxies).