sia-reactor 0.0.2 → 0.0.4

package/dist/utils.d.cts

@@ -1,11 +1,498 @@
-export { d as deepClone, a as deleteAny, g as getAny, b as getTrailPaths, c as getTrailRecords, i as inAny, e as inBoolArrOpt, f as isArr, h as isDef, j as isIter, k as isObj, l as isStrictObj, m as mergeObjs, n as nuke, p as parseAnyObj, o as parseEvOpts, s as setAny } from './index-DBfVdpnb.cjs';
-import { CamelCase, TitleCase, NoCamelCase } from './types.cjs';
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
 
-declare function capitalize<T extends string>(word?: T): TitleCase<T>;
-declare function camelize<T extends string>(str?: T, { source }?: RegExp, { preserveInnerCase: pIC, upperFirst: uF }?: {
-    preserveInnerCase?: boolean | undefined;
-    upperFirst?: boolean | undefined;
-}): CamelCase<T>;
-declare function uncamelize<T extends string, S extends string = " ">(str: T, separator?: S): NoCamelCase<T, S>;
+type NoTraverse =
+  | Primitive
+  | Function
+  | Date
+  | Error
+  | RegExp
+  | Promise<any>
+  | Map<any, any>
+  | WeakMap<any, any>
+  | Set<any>
+  | WeakSet<any>
+  | HTMLElement
+  | Element
+  | Node
+  | EventTarget
+  | Window
+  | Document
+  | DOMTokenList
+  | AbortSignal
+  | Inert<unknown>;
 
-export { camelize, capitalize, uncamelize };
+type Paths<T, S extends string = ".", D extends number = RDepth> = [D] extends [0]
+  ? never // Circuit Breaker Triggered
+  : T extends NoTraverse
+    ? never
+    : T extends readonly (infer U)[]
+      ? `${Extract<keyof T, number>}` | `${Extract<keyof T, number>}${S}${Paths<U, S, RPrev[D]>}`
+      : {
+          [K in keyof T & (string | number)]: T[K] extends Primitive
+            ? `${K}`
+            : `${K}` | `${K}${S}${Paths<T[K], S, RPrev[D]>}`;
+        }[keyof T & (string | number)];
+type WildPaths<T, S extends string = "."> = "*" | Paths<T, S>;
+type ChildPaths<T, P extends WildPaths<T>, S extends string = "."> = P extends "*"
+  ? Paths<T, S>
+  : P | Extract<Paths<T, S>, `${P}${S}${string}`>;
+
+type PathKey<T, P extends string = Paths<T>, S extends string = "."> = P extends "*"
+  ? keyof T & (string | number) // Or: DeepKeys<T>
+  : PathLeaf<P, S>; // Loose since reactor just slices strings
+type StrictPathKey<T, P extends string = Paths<T>, S extends string = "."> = P extends "*"
+  ? keyof T & (string | number) // Or: DeepKeys<T>
+  : P extends `${infer K}${S}${infer Rest}`
+    ? K extends keyof T
+      ? StrictPathKey<T[K], Rest, S>
+      : never
+    : P extends keyof T
+      ? P
+      : never; // Strict since it returns existing keys only
+
+type PathValue<T, P extends string = Paths<T>, S extends string = "."> = P extends "*"
+  ? any // Or: DeepValues<T>
+  : P extends `${infer K}${S}${infer Rest}`
+    ? K extends keyof T
+      ? PathValue<T[K], Rest, S>
+      : never
+    : P extends keyof T
+      ? T[P]
+      : never;
+
+type PathBranchValue<T, P extends string = Paths<T>, S extends string = "."> = P extends "*"
+  ? any // Or: DeepValues<T>
+  : P extends `${string}${S}${string}`
+    ? PathValue<T, PathBranch<P, S>, S>
+    : T;
+
+type Unflatten<T extends object, S extends string = "."> = UnionToIntersection<
+  {
+    [K in keyof T & string]: UnflattenKey<K, T[K], S>;
+  }[keyof T & string]
+>; // Turns dotted keys into nested objects while preserving value types
+type UnflattenKey<
+  K extends string,
+  V,
+  S extends string,
+> = K extends `${infer Head}${S}${infer Tail}`
+  ? { [P in Head]: UnflattenKey<Tail, V, S> }
+  : { [P in K]: V };
+
+// Helpers
+type PathLeaf<
+  P extends string,
+  S extends string = ".",
+> = P extends `${infer _Head}${S}${infer Tail}` ? PathLeaf<Tail, S> : P;
+
+type PathBranch<
+  P extends string,
+  S extends string = ".",
+> = P extends `${infer Head}${S}${infer Tail}`
+  ? Tail extends `${string}${S}${string}`
+    ? `${Head}${S}${PathBranch<Tail, S>}`
+    : Head
+  : never;
+
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+  k: infer I,
+) => void
+  ? I
+  : never;
+
+// --- "It's not that deep" WARRIORS ---
+type DeepKeys<T, D extends number = RDepth> = [D] extends [0]
+  ? never
+  : T extends NoTraverse
+    ? never
+    : T extends readonly any[]
+      ? DeepKeys<T[number], RPrev[D]>
+      : {
+          [K in keyof T & (string | number)]: K | DeepKeys<T[K], RPrev[D]>;
+        }[keyof T & (string | number)];
+
+type DeepMerge<T1, T2, D extends number = RDepth> = [D] extends [0]
+  ? never
+  : T2 extends object
+    ? T1 extends object
+      ? {
+          [K in keyof T1 | keyof T2]: K extends keyof T2
+            ? K extends keyof T1
+              ? DeepMerge<T1[K], T2[K], RPrev[D]>
+              : T2[K]
+            : K extends keyof T1
+              ? T1[K]
+              : never;
+        }
+      : T2
+    : T2;
+
+type DeepPartial<T, D extends number = RDepth> = [D] extends [0]
+  ? never
+  : T extends Function
+    ? T
+    : T extends Array<infer U>
+      ? Array<DeepPartial<U, RPrev[D]>>
+      : T extends ReadonlyArray<infer U>
+        ? ReadonlyArray<DeepPartial<U, RPrev[D]>>
+        : T extends object
+          ? { [P in keyof T]?: DeepPartial<T[P], RPrev[D]> }
+          : T;
+
+type DeepRequired<T, D extends number = RDepth> = [D] extends [0]
+  ? never
+  : T extends Function
+    ? T
+    : T extends Array<infer U>
+      ? Array<DeepRequired<U, RPrev[D]>>
+      : T extends ReadonlyArray<infer U>
+        ? ReadonlyArray<DeepRequired<U, RPrev[D]>>
+        : T extends object
+          ? { [P in keyof T]-?: DeepRequired<T[P], RPrev[D]> }
+          : T;
+
+// --- RECURSION LIMITERS ---
+type RDepth = 10; // current limit for state trees, observed ts max - 19; limit needed cuz of ts bundlers
+// This tuple maps a number to the number below it (Index 4 contains 3) allowing `RPrev[D]` to subtract 1 from our depth.
+type RPrev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19];
+
+declare const methods: readonly ["tick", "stall", "nostall", "get", "gonce", "noget", "set", "sonce", "noset", "delete", "donce", "nodelete", "watch", "wonce", "nowatch", "on", "once", "off", "cascade", "snapshot", "reset", "destroy"];
+type Method = (typeof methods)[number];
+type Prefix<P extends ReactivePrefs | undefined> = P extends {
+    prefix?: infer X extends string;
+} ? X : "";
+type Suffix<P extends ReactivePrefs | undefined> = P extends {
+    suffix?: infer X extends string;
+} ? X : "";
+type Whitelist<P extends ReactivePrefs | undefined> = P extends {
+    whitelist?: infer W extends readonly Method[];
+} ? W[number] : never;
+type ReactiveMethodMap<T extends object, P extends ReactivePrefs | undefined> = {
+    [K in Method as [Prefix<P>, Suffix<P>] extends ["", ""] ? (P extends {
+        whitelist: readonly Method[];
+    } ? (K extends Whitelist<P> ? never : K) : K) : P extends {
+        whitelist: readonly Method[];
+    } ? (K extends Whitelist<P> ? `${Prefix<P>}${K}${Suffix<P>}` : K) : `${Prefix<P>}${K}${Suffix<P>}`]: Pick<Reactor<T>, Method>[K];
+};
+interface ReactivePrefs {
+    prefix?: string;
+    suffix?: string;
+    whitelist?: readonly Method[];
+}
+type Reactive<T extends object, P extends ReactivePrefs | undefined = undefined> = T & ReactiveMethodMap<T, P> & {
+    __Reactor__: Reactor<T>;
+};
+declare function reactive<T extends object, const P extends ReactivePrefs | undefined = undefined>(target: T | Reactor<T>, options?: ReactorOptions<T>, prefs?: P): Reactive<T, P>;
+declare function inert<T extends object>(target: T): Inert<T>;
+declare function live<T extends object>(target: T): Live<T>;
+declare function isInert<T extends object>(target: T): target is Inert<T>;
+declare function intent<T extends object>(target: T): Intent<T>;
+declare function state<T extends object>(target: T): State<T>;
+declare function isIntent<T extends object>(target: T): target is Intent<T>;
+declare function volatile<T extends object>(target: T): Volatile<T>;
+declare function stable<T extends object>(target: T): Stable<T>;
+declare function isVolatile<T extends object>(target: T): target is Volatile<T>;
+declare function getVersion<T extends object>(target: T): number;
+declare function getSnapshotVersion<T extends object>(target: T): number;
+
+// ===========================================================================
+// CORE MARKERS & STATE WRAPPERS
+// ===========================================================================
+
+type Inert<T> = T & { [INERTIA]?: true };
+type Live<T> = T extends Inert<infer U> ? U : T;
+
+type Intent<T> = T & { [REJECTABLE]?: true };
+type State<T> = T extends Intent<infer U> ? U : T;
+
+type Volatile<T> = T & { [INDIFFABLE]?: true };
+type Stable<T> = T extends Volatile<infer U> ? U : T;
+
+
+// ===========================================================================
+// EVENT SYSTEM & PAYLOADS
+// ===========================================================================
+
+interface Target<T, P extends WildPaths<T> = WildPaths<T>> {
+  path: P;
+  value: PathValue<T, P>;
+  oldValue?: PathValue<T, P>;
+  key: PathKey<T, P>;
+  object: PathBranchValue<T, P>;
+}
+
+// Discriminated Payload Type (Creates the IDE magic)
+type Payload<T, P extends WildPaths<T> = WildPaths<T>> =
+  | DirectPayload<T, P>
+  | UpdatePayload<T, P>;
+
+interface BasePayload<T, P extends WildPaths<T> = WildPaths<T>> {
+  currentTarget: Target<T, P>; // use this to survive shape changes from nesting
+  root: T;
+  terminated?: boolean; // for mediators to signal operation termination but doesn't stop the chain
+  rejectable: boolean;
+}
+interface DirectPayload<T, P extends WildPaths<T> = WildPaths<T>> extends BasePayload<T, P> {
+  type: "init" | "get" | "set" | "delete"; // init during `immediate: true` sync
+  target: Target<T, P>;
+}
+interface UpdatePayload<T, P extends WildPaths<T> = WildPaths<T>> extends BasePayload<T, P> {
+  type: "update";
+  target: Target<T, ChildPaths<T, P>>; // Target is strictly one of the child paths!
+}
+
+// Discriminated Event Type (Creates the IDE magic)
+type REvent<T, P extends WildPaths<T> = WildPaths<T>> =
+  | (Omit<ReactorEvent<T, P>, OverrideEvProp> &
+      DirectPayload<T, P> &
+      OverrideEvPart<DirectPayload<T, P>>)
+  | (Omit<ReactorEvent<T, P>, OverrideEvProp> &
+      UpdatePayload<T, P> &
+      OverrideEvPart<UpdatePayload<T, P>>);
+
+type OverrideEvProp = "type" | "target" | "value" | "oldValue" | "path";
+interface OverrideEvPart<PL extends { target: { path: any; value: any; oldValue?: any } }> {
+  path: PL["target"]["path"];
+  value: PL["target"]["value"];
+  oldValue: PL["target"]["oldValue"];
+}
+
+// ===========================================================================
+// REACTIVITY CALLBACKS (The Handlers)
+// ===========================================================================
+
+type Getter<T, P extends WildPaths<T> = WildPaths<T>> = (
+  value: PathValue<T, P>,
+  payload: Payload<T, P>,
+) => PathValue<T, P> | undefined;
+
+type Setter<T, P extends WildPaths<T> = WildPaths<T>> = (
+  value: PathValue<T, P>,
+  terminated: boolean,
+  payload: Payload<T, P>,
+) => PathValue<T, P> | typeof TERMINATOR | undefined;
+
+type Deleter<T, P extends WildPaths<T> = WildPaths<T>> = (
+  terminated: boolean,
+  payload: Payload<T, P>,
+) => typeof TERMINATOR | undefined;
+
+type Watcher<T, P extends WildPaths<T> = WildPaths<T>> = (
+  value: PathValue<T, P>,
+  payload: Payload<T, P>,
+) => void;
+
+type Listener<T, P extends WildPaths<T> = WildPaths<T>> = (event: REvent<T, P>) => void;
+
+// ===========================================================================
+// ENGINE RECORDS (Internal Storage)
+// ===========================================================================
+
+type GetterRecord<T extends object, P extends WildPaths<T> = WildPaths<T>> = {
+  cb: Getter<T, P>;
+  clup: () => ReturnType<Reactor<T>["noget"]>;
+  sclup?: () => void;
+} & SyncOptionsTuple;
+
+type SetterRecord<T extends object, P extends WildPaths<T> = WildPaths<T>> = {
+  cb: Setter<T, P>;
+  clup: () => ReturnType<Reactor<T>["noset"]>;
+  sclup?: () => void;
+} & SyncOptionsTuple;
+
+type DeleterRecord<T extends object, P extends WildPaths<T> = WildPaths<T>> = {
+  cb: Deleter<T, P>;
+  clup: () => ReturnType<Reactor<T>["nodelete"]>;
+  sclup?: () => void;
+} & SyncOptionsTuple;
+
+type WatcherRecord<T extends object, P extends WildPaths<T> = WildPaths<T>> = {
+  cb: Watcher<T, P>;
+  clup: () => ReturnType<Reactor<T>["nowatch"]>;
+  sclup?: () => void;
+} & SyncOptionsTuple;
+
+type ListenerRecord<T extends object, P extends WildPaths<T> = WildPaths<T>> = {
+  cb: Listener<T, P>;
+  clup: () => ReturnType<Reactor<T>["off"]>;
+  sclup?: () => void;
+} & ListenerOptionsTuple;
+
+// ===========================================================================
+// CONFIGURATION OPTIONS
+// ===========================================================================
+
+interface SyncOptionsTuple {
+  lazy?: boolean;
+  once?: boolean;
+  signal?: AbortSignal;
+  immediate?: boolean | "auto";
+} // "*" path apart from listener's should not use `immediate`
+type SyncOptions = boolean | SyncOptionsTuple;
+
+interface ListenerOptionsTuple extends Omit<SyncOptionsTuple, "lazy"> {
+  capture?: boolean;
+  depth?: number;
+}
+type ListenerOptions = boolean | ListenerOptionsTuple;
+
+// "almighty" mediation, (mediator|listener) for desired path, equality checks eg: `object.is()`
+interface ReactorOptions<T extends object, P extends Paths<T> = Paths<T>> {
+  get?: (
+    object: PathBranchValue<T, P>,
+    key: PathKey<T, P>,
+    value: PathValue<T, P>,
+    receiver: Reactive<T>,
+    path: Paths<T> | Paths<T>[],
+  ) => PathValue<T, P> | undefined;
+  set?: (
+    object: PathBranchValue<T, P>,
+    key: PathKey<T, P>,
+    value: PathValue<T, P>,
+    oldValue: PathValue<T, P>,
+    receiver: Reactive<T>,
+    path: Paths<T> | Paths<T>[],
+  ) => PathValue<T, P> | typeof TERMINATOR | undefined;
+  delete?: (
+    object: PathBranchValue<T, P>,
+    key: PathKey<T, P>,
+    oldValue: PathValue<T, P>,
+    receiver: Reactive<T>,
+    path: Paths<T> | Paths<T>[],
+  ) => typeof TERMINATOR | undefined;
+  debug?: boolean;
+  crossRealms?: boolean; // needed for object type detection if using across realms e.g, iframes or other environments
+  smartCloning?: boolean; // one-time set for structural sharing, needs `.referenceTracking: true`
+  eventBubbling?: boolean; // default true, set to false to prevent bubbling (not recommended if you want power)
+  lineageTracing?: boolean; // one-time set for tree walking to search for refs on property access, needs `.referenceTracking = true`
+  batchingFunction?: (cb: () => void) => void; // one-time set for listener's notifications, e.g: `queueMicrotask`, `unstable_batchedUpdates` from ReactDOM
+  referenceTracking?: boolean; // one-time set to activate
+} // debating making use of the Reflect API opt-in
+
+declare function isDef(val: any): boolean;
+declare function isArr<T = unknown>(obj: any): obj is T[];
+declare function isObj<T extends object = object>(obj: any, checkArr?: boolean): obj is T;
+declare function isStrictObj<T extends object = object>(obj: any, crossRealms?: boolean, typecheck?: boolean): obj is T;
+declare function isIter<T = unknown>(obj: any): obj is Iterable<T>;
+declare function inBoolArrOpt(opt: any, str: string): boolean;
+declare function setAny<T extends object, const S extends string = ".">(target: T, key: Paths<T, S>, value: PathValue<T, typeof key, S>, separator?: S, keyFunc?: (p: string) => string): void;
+declare function getAny<T extends object, const S extends string = ".">(source: T, key: Paths<T, S>, separator?: S, keyFunc?: (p: string) => string): PathValue<T, typeof key, S> | undefined;
+declare function deleteAny<T extends object, const S extends string = ".">(target: T, key: Paths<T, S>, separator?: S, keyFunc?: (p: string) => string): void;
+declare function inAny<T extends object, const S extends string = ".">(source: T, key: string | Paths<T, S>, separator?: S, keyFunc?: (p: string) => string): boolean;
+declare function parseAnyObj<T extends Record<string, any>, const S extends string = ".">(obj: T, separator?: S, keyFunc?: (p: string) => string, visited?: WeakSet<WeakKey>): Unflatten<T, S>;
+declare function parseEvOpts<T extends object>(options: T | boolean | undefined, opts: (keyof T)[] | readonly (keyof T)[], boolOpt?: keyof T, result?: T): T;
+declare function mergeObjs<T1 extends object, T2 extends object>(o1: T1, o2: T2): DeepMerge<T1, T2>;
+declare function mergeObjs<T1 extends object>(o1: T1): T1;
+declare function mergeObjs<T2 extends object>(o1: undefined | null, o2: T2): T2;
+declare function getTrailPaths<T>(path: WildPaths<T>, reverse?: boolean): WildPaths<T>[];
+declare function getTrailRecords<T extends object>(obj: T, path: WildPaths<T>): [WildPaths<T>, PathValue<T, WildPaths<T>>, PathValue<T, WildPaths<T>>][];
+declare function deepClone<T>(obj: T, crossRealms?: boolean, visited?: WeakMap<WeakKey, any>): T;
+declare function nuke(target: any): void;
+
+declare const INERTIA: unique symbol;
+declare const REJECTABLE: unique symbol;
+declare const INDIFFABLE: unique symbol;
+declare const TERMINATOR: unique symbol;
+declare class ReactorEvent<T, P extends WildPaths<T> = WildPaths<T>> {
+    static readonly NONE = 0;
+    static readonly CAPTURING_PHASE = 1;
+    static readonly AT_TARGET = 2;
+    static readonly BUBBLING_PHASE = 3;
+    eventPhase: number;
+    type: Payload<T, P>["type"];
+    currentTarget: Payload<T, P>["currentTarget"];
+    readonly staticType: Payload<T, P>["type"];
+    readonly target: Payload<T, P>["target"];
+    readonly root: Payload<T, P>["root"];
+    readonly path: Payload<T, P>["target"]["path"];
+    readonly value: Payload<T, P>["target"]["value"];
+    readonly oldValue: Payload<T, P>["target"]["oldValue"];
+    readonly rejectable: boolean;
+    readonly bubbles: boolean;
+    protected _propagationStopped: boolean;
+    protected _immediatePropagationStopped: boolean;
+    protected _resolved: string;
+    protected _rejected: string;
+    protected _warn: (...args: any[]) => void;
+    constructor(payload: Payload<T, P>, bubbles?: boolean, canWarn?: boolean);
+    get propagationStopped(): boolean;
+    stopPropagation(): void;
+    get immediatePropagationStopped(): boolean;
+    stopImmediatePropagation(): void;
+    get resolved(): string;
+    resolve(message?: string): void;
+    get rejected(): string;
+    reject(reason?: string): void;
+    composedPath(): WildPaths<T>[];
+    get canWarn(): boolean;
+}
+declare class Reactor<T extends object> {
+    protected getters?: Map<WildPaths<T>, Array<GetterRecord<T>>>;
+    protected setters?: Map<WildPaths<T>, Array<SetterRecord<T>>>;
+    protected deleters?: Map<WildPaths<T>, Array<DeleterRecord<T>>>;
+    protected watchers?: Map<WildPaths<T>, Array<WatcherRecord<T>>>;
+    protected listeners?: Map<WildPaths<T>, Array<ListenerRecord<T>>>;
+    protected lineage?: WeakMap<object, (object | string)[]>;
+    protected queue?: Set<() => void>;
+    protected batch?: Map<Paths<T>, Payload<T>>;
+    protected proxyCache: WeakMap<object, any>;
+    protected snapshotCache?: WeakMap<object, any>;
+    protected log: (...args: any[]) => void;
+    config: Omit<ReactorOptions<T>, "debug" | "referenceTracking" | "lineageTracing" | "smartCloning">;
+    core: T;
+    protected isLogging: boolean;
+    protected isTracing: boolean;
+    protected isTracking: boolean;
+    protected isSCloning: boolean;
+    protected isBatching: boolean;
+    constructor(obj?: T, options?: ReactorOptions<T>);
+    protected proxied<O extends object>(obj: O, rejectable?: boolean, indiffable?: boolean, parent?: object, key?: string, path?: string): O;
+    protected trace(target: object, path: string, paths?: string[], visited?: WeakSet<object>): Paths<T>[];
+    protected link(target: any, parent: object, key: string, typecheck?: boolean, es?: (object | string)[]): void;
+    protected unlink(target: any, parent: object, key: string): void;
+    protected stamp(target: any, typecheck?: boolean): void;
+    protected mediate<P extends WildPaths<T>>(path: WildPaths<T>, payload: Payload<T, P>, type: "get", cords: GetterRecord<T>[]): PathValue<T, P>;
+    protected mediate<P extends WildPaths<T>>(path: WildPaths<T>, payload: Payload<T, P>, type: "set", cords: SetterRecord<T>[]): PathValue<T, P>;
+    protected mediate<P extends WildPaths<T>>(path: WildPaths<T>, payload: Payload<T, P>, type: "delete", cords: DeleterRecord<T>[]): PathValue<T, P>;
+    protected notify<P extends Paths<T>>(path: P, payload: Payload<T, P>): void;
+    protected schedule<P extends Paths<T>>(path: P, payload: Payload<T, P>): void;
+    protected initBatching(): void;
+    protected flush(): void;
+    protected wave(path: Paths<T>, payload: Payload<T>): void;
+    protected fire([path, object, value]: ReturnType<typeof getTrailRecords<T>>[number], e: REvent<T>, isCapture: boolean, cords?: ListenerRecord<T>[] | undefined): void;
+    tick(paths?: Paths<T> | Iterable<Paths<T>>): void;
+    stall(task: () => any): void;
+    nostall(task: () => any): boolean | undefined;
+    protected bind<Cb>(cord: GetterRecord<T> | SetterRecord<T> | DeleterRecord<T> | WatcherRecord<T> | ListenerRecord<T>, signal?: AbortSignal): Cb;
+    protected clone(obj: any, raw: boolean, visited?: WeakMap<WeakKey, any>): any;
+    getDepth(p: string, d?: number): number;
+    protected getContext<P extends WildPaths<T>>(path: P): Target<T, P>;
+    protected syncAdd<P extends WildPaths<T>>(key: "get" | "set" | "delete" | "watch", path: P, cb: any, opts: SyncOptions | undefined, onImmediate?: (immediate: boolean | "auto") => void): () => boolean | undefined;
+    protected syncDrop<P extends WildPaths<T>>(store: Map<WildPaths<T>, any[]> | undefined, path: P, cb: any): boolean | undefined;
+    get<P extends WildPaths<T>>(path: P, cb: Getter<T, P>, opts?: SyncOptions): Reactor<T>["noget"];
+    gonce<P extends WildPaths<T>>(path: P, cb: Getter<T, P>, opts?: SyncOptions): Reactor<T>["noget"];
+    noget<P extends WildPaths<T>>(path: P, cb: Getter<T, P>): boolean | undefined;
+    set<P extends WildPaths<T>>(path: P, cb: Setter<T, P>, opts?: SyncOptions): Reactor<T>["noset"];
+    sonce<P extends WildPaths<T>>(path: P, cb: Setter<T, P>, opts?: SyncOptions): Reactor<T>["noset"];
+    noset<P extends WildPaths<T>>(path: P, cb: Setter<T, P>): boolean | undefined;
+    delete<P extends WildPaths<T>>(path: P, cb: Deleter<T, P>, opts?: SyncOptions): Reactor<T>["nodelete"];
+    donce<P extends WildPaths<T>>(path: P, cb: Deleter<T, P>, opts?: SyncOptions): Reactor<T>["nodelete"];
+    nodelete<P extends WildPaths<T>>(path: P, cb: Deleter<T, P>): boolean | undefined;
+    watch<P extends WildPaths<T>>(path: P, cb: Watcher<T, P>, opts?: SyncOptions): Reactor<T>["nowatch"];
+    wonce<P extends WildPaths<T>>(path: P, cb: Watcher<T, P>, opts?: SyncOptions): Reactor<T>["nowatch"];
+    nowatch<P extends WildPaths<T>>(path: P, cb: Watcher<T, P>): boolean | undefined;
+    on<P extends WildPaths<T>>(path: P, cb: Listener<T, P>, options?: ListenerOptions): Reactor<T>["off"];
+    once<P extends WildPaths<T>>(path: P, cb: Listener<T, P>, options?: ListenerOptions): Reactor<T>["off"];
+    off<P extends WildPaths<T>>(path: P, cb: Listener<T, P>, options?: ListenerOptions): boolean | undefined;
+    snapshot(raw?: boolean, branch?: T): T;
+    cascade({ type, currentTarget: { path, value: news, oldValue: olds } }: ReactorEvent<T>, objSafe?: boolean): void;
+    reset(): void;
+    destroy(): void;
+    get canLog(): boolean;
+    set canLog(value: boolean);
+    get canTrackReferences(): boolean;
+    get canTraceLineage(): boolean;
+    get canSmartClone(): boolean;
+}
+
+export { live as $, type StrictPathKey as A, type SyncOptions as B, type ChildPaths as C, type DeepKeys as D, type SyncOptionsTuple as E, type Target as F, type Getter as G, type UnionToIntersection as H, type Inert as I, type UpdatePayload as J, type WatcherRecord as K, type Listener as L, type WildPaths as M, getSnapshotVersion as N, getVersion as O, type PathBranch as P, inert as Q, type REvent as R, type Setter as S, TERMINATOR as T, type Unflatten as U, type Volatile as V, type Watcher as W, intent as X, isInert as Y, isIntent as Z, isVolatile as _, type DeepMerge as a, methods as a0, reactive as a1, stable as a2, state as a3, volatile as a4, type DeepPartial as b, type DeepRequired as c, type Deleter as d, deepClone, deleteAny, type DeleterRecord as e, type DirectPayload as f, type GetterRecord as g, getAny, getTrailPaths, getTrailRecords, type Intent as h, type ListenerOptions as i, inAny, inBoolArrOpt, isArr, isDef, isIter, isObj, isStrictObj, type ListenerOptionsTuple as j, type ListenerRecord as k, type Live as l, type PathBranchValue as m, mergeObjs, type PathKey as n, nuke, type PathLeaf as o, type PathValue as p, parseAnyObj, parseEvOpts, type Paths as q, type Payload as r, type Reactive as s, setAny, type ReactivePrefs as t, Reactor as u, ReactorEvent as v, type ReactorOptions as w, type SetterRecord as x, type Stable as y, type State as z };