wenay-common2 1.0.52 → 1.0.55

package/lib/Common/ObserveAll2/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./reactive2";
 export * from "./store";
+export * from "./store-replay";

package/lib/Common/ObserveAll2/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./reactive2"), exports);
 __exportStar(require("./store"), exports);
+__exportStar(require("./store-replay"), exports);

package/lib/Common/ObserveAll2/reactive2.d.ts

@@ -1,4 +1,8 @@
 type Fn = () => void;
+export type ReactiveChange = {
+    paths: PropertyKey[][];
+};
+type PathUpdateFn = (change: ReactiveChange) => void;
 type Drain = 'micro' | 'immediate' | number | ((flush: Fn) => void);
 export type Opts = {
     drain?: Drain;
@@ -7,7 +11,9 @@ export type Opts = {
 };
 export declare function reactive<T extends object>(root: T, opts?: Opts): T;
 export declare function isReactive(p: any): boolean;
+export declare function toRaw<T>(p: T): T;
 export declare function onUpdate(p: any, cb: Fn): () => void;
+export declare function onUpdatePaths(p: any, cb: PathUpdateFn): () => void;
 export declare function flushReactive(p: any): Promise<void>;
 export declare function listenUpdate(p: any): {
     func: import("../events/Listen3").Listener<[]>;
@@ -18,6 +24,7 @@ export declare function listenUpdate(p: any): {
     onClose: (cb: () => void) => () => void;
     removeEventClose: (cb: () => void) => void;
     on: import("../events/Listen3").ListenOn<[]>;
+    off: (k: (string | symbol) | import("../events/Listen3").Listener<[]> | null) => void;
     addListen: (cb: import("../events/Listen3").Listener<[]>, opts?: {
         cbClose?: () => void;
         key?: string | symbol;
@@ -29,5 +36,26 @@ export declare function listenUpdate(p: any): {
     count: () => number;
     readonly getAllKeys: (string | symbol)[];
 };
+export declare function listenUpdatePaths(p: any): {
+    func: import("../events/Listen3").Listener<[ReactiveChange]>;
+    isRun: () => boolean;
+    run: () => void;
+    close: () => void;
+    eventClose: (cb: () => void) => () => void;
+    onClose: (cb: () => void) => () => void;
+    removeEventClose: (cb: () => void) => void;
+    on: import("../events/Listen3").ListenOn<[ReactiveChange]>;
+    off: (k: (string | symbol) | import("../events/Listen3").Listener<[ReactiveChange]> | null) => void;
+    addListen: (cb: import("../events/Listen3").Listener<[ReactiveChange]>, opts?: {
+        cbClose?: () => void;
+        key?: string | symbol;
+    }) => () => void;
+    removeListen: (k: (string | symbol) | import("../events/Listen3").Listener<[ReactiveChange]> | null) => void;
+    once: (cb: import("../events/Listen3").Listener<[ReactiveChange]>, opts?: {
+        key?: string | symbol;
+    }) => () => void;
+    count: () => number;
+    readonly getAllKeys: (string | symbol)[];
+};
 export type Reactive<T extends object> = T;
 export {};

package/lib/Common/ObserveAll2/reactive2.js

@@ -2,9 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.reactive = reactive;
 exports.isReactive = isReactive;
+exports.toRaw = toRaw;
 exports.onUpdate = onUpdate;
+exports.onUpdatePaths = onUpdatePaths;
 exports.flushReactive = flushReactive;
 exports.listenUpdate = listenUpdate;
+exports.listenUpdatePaths = listenUpdatePaths;
 const Listen_1 = require("../events/Listen");
 const NODE = Symbol('reactive2.node');
 const isObj = (v) => v != null && typeof v == 'object';
@@ -30,7 +33,7 @@ function reactive(root, opts = {}) {
     const { drain = 'immediate', depth = Infinity, eager = false } = opts;
     const fire = scheduler(drain);
     const eng = {
-        live: 0, dirty: new Set(), scheduled: false, waiters: new Set(), depth,
+        live: 0, pathLive: 0, dirty: new Set(), dirtyPaths: [], scheduled: false, waiters: new Set(), depth,
         schedule() {
             if (eng.scheduled)
                 return;
@@ -39,8 +42,10 @@ function reactive(root, opts = {}) {
                 eng.scheduled = false;
                 const batch = [...eng.dirty];
                 eng.dirty.clear();
+                const dirtyPaths = eng.dirtyPaths;
+                eng.dirtyPaths = [];
                 let err;
-                for (const n of batch)
+                for (const n of batch) {
                     for (const cb of [...n.subs]) {
                         try {
                             cb();
@@ -49,7 +54,20 @@ function reactive(root, opts = {}) {
                             err ??= e;
                         }
                     }
-                if (!eng.scheduled && eng.dirty.size == 0) {
+                    if (n.pathSubs.size) {
+                        const paths = pathsForNode(n, dirtyPaths);
+                        if (paths.length)
+                            for (const cb of [...n.pathSubs]) {
+                                try {
+                                    cb({ paths });
+                                }
+                                catch (e) {
+                                    err ??= e;
+                                }
+                            }
+                    }
+                }
+                if (!eng.scheduled && eng.dirty.size == 0 && eng.dirtyPaths.length == 0) {
                     const waiters = [...eng.waiters];
                     eng.waiters.clear();
                     for (const w of waiters)
@@ -60,13 +78,16 @@ function reactive(root, opts = {}) {
             });
         },
     };
-    const rootNode = makeNode(root, null, 0, eng);
+    const rootNode = makeNode(root, null, [], 0, eng);
     if (eager)
         prewalk(rootNode);
     return rootNode.proxy;
 }
-function makeNode(target, parent, level, eng) {
-    const node = { target, parent, active: true, level, subs: new Set(), kids: new Map(), proxy: null, eng };
+function makeNode(target, parent, path, level, eng) {
+    const node = {
+        target, parent, path, active: true, level,
+        subs: new Set(), pathSubs: new Set(), kids: new Map(), proxy: null, eng,
+    };
     const proxyTarget = (Array.isArray(target) ? [] : {});
     node.proxy = new Proxy(proxyTarget, {
         get(_, k) {
@@ -78,7 +99,7 @@ function makeNode(target, parent, level, eng) {
             if (isReactiveObj(v) && level < eng.depth) {
                 let kid = node.kids.get(k);
                 if (!kid) {
-                    kid = makeNode(v, node, level + 1, eng);
+                    kid = makeNode(v, node, [...node.path, k], level + 1, eng);
                     node.kids.set(k, kid);
                 }
                 else if (kid.target !== v)
@@ -88,8 +109,10 @@ function makeNode(target, parent, level, eng) {
             return v;
         },
         set(_, k, v) {
+            v = toRaw(v);
             if (Object.is(node.target[k], v))
                 return true;
+            const dirtyPath = dirtyPathFor(node, k);
             node.target[k] = v;
             if (Array.isArray(proxyTarget) && k == "length")
                 proxyTarget.length = v;
@@ -97,21 +120,23 @@ function makeNode(target, parent, level, eng) {
             if (kid)
                 rebind(kid, v);
             if (eng.live > 0)
-                bubble(node);
+                bubble(node, dirtyPath);
             return true;
         },
         defineProperty(_, k, d) {
             const old = node.target[k];
-            const ok = Reflect.defineProperty(node.target, k, d);
+            const desc = 'value' in d ? { ...d, value: toRaw(d.value) } : d;
+            const ok = Reflect.defineProperty(node.target, k, desc);
             if (!ok)
                 return false;
-            if (d.configurable === false) {
-                const mirror = Reflect.defineProperty(proxyTarget, k, d);
+            if (desc.configurable === false) {
+                const mirror = Reflect.defineProperty(proxyTarget, k, desc);
                 if (!mirror)
                     return false;
             }
             const v = node.target[k];
             if (!Object.is(old, v)) {
+                const dirtyPath = dirtyPathFor(node, k);
                 const kid = node.kids.get(k);
                 if (kid) {
                     if (isReactiveObj(v))
@@ -123,13 +148,14 @@ function makeNode(target, parent, level, eng) {
                     }
                 }
                 if (eng.live > 0)
-                    bubble(node);
+                    bubble(node, dirtyPath);
             }
             return true;
         },
         deleteProperty(_, k) {
             if (!(k in node.target))
                 return true;
+            const dirtyPath = dirtyPathFor(node, k);
             delete node.target[k];
             const kid = node.kids.get(k);
             if (kid) {
@@ -138,7 +164,7 @@ function makeNode(target, parent, level, eng) {
                 detachTree(kid);
             }
             if (eng.live > 0)
-                bubble(node);
+                bubble(node, dirtyPath);
             return true;
         },
         has(_, k) { return k in node.target; },
@@ -165,16 +191,18 @@ function makeNode(target, parent, level, eng) {
     });
     return node;
 }
-function bubble(from) {
+function bubble(from, dirtyPath) {
     const eng = from.eng;
+    if (eng.pathLive > 0 && dirtyPath)
+        addDirtyPath(eng, dirtyPath);
     for (let n = from; n && n.active; n = n.parent)
-        if (n.subs.size)
+        if (n.subs.size || n.pathSubs.size)
             eng.dirty.add(n);
     eng.schedule();
 }
 function rebind(node, next) {
     node.target = next;
-    if (node.subs.size)
+    if (node.subs.size || node.pathSubs.size)
         node.eng.dirty.add(node);
     for (const [k, kid] of [...node.kids]) {
         const cv = isReactiveObj(next) ? next[k] : undefined;
@@ -188,11 +216,37 @@ function rebind(node, next) {
     }
 }
 function markChanged(node) {
-    if (node.subs.size)
+    if (node.subs.size || node.pathSubs.size)
         node.eng.dirty.add(node);
     for (const kid of node.kids.values())
         markChanged(kid);
 }
+function dirtyPathFor(node, key) {
+    return Array.isArray(node.target) ? [...node.path] : [...node.path, key];
+}
+function addDirtyPath(eng, path) {
+    if (!eng.dirtyPaths.some(p => samePath(p, path)))
+        eng.dirtyPaths.push([...path]);
+}
+function samePath(a, b) {
+    return a.length == b.length && a.every((k, i) => Object.is(k, b[i]));
+}
+function startsWithPath(path, prefix) {
+    return prefix.length <= path.length && prefix.every((k, i) => Object.is(k, path[i]));
+}
+function pathsForNode(node, dirtyPaths) {
+    const out = [];
+    for (const path of dirtyPaths) {
+        let next = null;
+        if (startsWithPath(path, node.path))
+            next = path.slice(node.path.length);
+        else if (startsWithPath(node.path, path))
+            next = [];
+        if (next && !out.some(p => samePath(p, next)))
+            out.push(next);
+    }
+    return out;
+}
 function detachTree(node) {
     if (!node.active)
         return;
@@ -218,6 +272,10 @@ function isReactive(p) {
     const node = p && p[NODE];
     return !!node && node.active;
 }
+function toRaw(p) {
+    const node = p && p[NODE];
+    return node ? node.target : p;
+}
 function onUpdate(p, cb) {
     const node = p && p[NODE];
     if (!node)
@@ -232,12 +290,33 @@ function onUpdate(p, cb) {
         return; done = true; if (node.subs.delete(sub))
         node.eng.live--; };
 }
+function onUpdatePaths(p, cb) {
+    const node = p && p[NODE];
+    if (!node)
+        throw new Error('onUpdatePaths: not a reactive object');
+    if (!node.active)
+        throw new Error('onUpdatePaths: reactive object is detached');
+    const sub = (change) => cb(change);
+    node.pathSubs.add(sub);
+    node.eng.live++;
+    node.eng.pathLive++;
+    let done = false;
+    return () => {
+        if (done)
+            return;
+        done = true;
+        if (node.pathSubs.delete(sub)) {
+            node.eng.live--;
+            node.eng.pathLive--;
+        }
+    };
+}
 function flushReactive(p) {
     const node = p && p[NODE];
     if (!node)
         throw new Error('flushReactive: not a reactive object');
     const eng = node.eng;
-    if (!eng.scheduled && eng.dirty.size == 0)
+    if (!eng.scheduled && eng.dirty.size == 0 && eng.dirtyPaths.length == 0)
         return Promise.resolve();
     return new Promise(resolve => { eng.waiters.add(resolve); });
 }
@@ -252,3 +331,14 @@ function listenUpdate(p) {
     });
     return listen;
 }
+function listenUpdatePaths(p) {
+    const listen = (0, Listen_1.funcListenCallbackBase)((emit) => onUpdatePaths(p, change => emit(change)), {
+        event: (type, count, api) => {
+            if (type == "add" && count == 1 && !api.isRun())
+                api.run();
+            if (type == "remove" && count == 0 && api.isRun())
+                api.close();
+        },
+    });
+    return listen;
+}

package/lib/Common/ObserveAll2/store-replay.d.ts

@@ -0,0 +1,102 @@
+import { Store, StorePatch } from './store';
+import { ReplayListenOptions } from '../events/replay-listen';
+import { ReplayRemote, ReplaySubscribeOpts } from '../events/replay-wire';
+import { ReplayStorage } from '../events/replay-history';
+export type StoreReplayOpts = Pick<ReplayListenOptions<[StorePatch]>, 'history' | 'getSince' | 'onJournal' | 'now'>;
+export declare function storePatchKey(patch: StorePatch): string | null;
+export declare function exposeStoreReplay<T extends object>(store: Store<T>, opts?: StoreReplayOpts): {
+    api: {
+        replay: {
+            line: {
+                func: import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>;
+                isRun: () => boolean;
+                run: () => void;
+                close: () => void;
+                eventClose: (cb: () => void) => () => void;
+                onClose: (cb: () => void) => () => void;
+                removeEventClose: (cb: () => void) => void;
+                on: import("../..").ListenOn<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>;
+                off: (k: (string | symbol) | import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]> | null) => void;
+                addListen: (cb: import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>, opts?: {
+                    cbClose?: () => void;
+                    key?: string | symbol;
+                }) => () => void;
+                removeListen: (k: (string | symbol) | import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]> | null) => void;
+                once: (cb: import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>, opts?: {
+                    key?: string | symbol;
+                }) => () => void;
+                count: () => number;
+                readonly getAllKeys: (string | symbol)[];
+            };
+            since: (seq: number) => import("../events/replay-listen").ReplayEvent<[StorePatch]>[] | null;
+            keyframe: () => import("../events/replay-listen").ReplayEvent<[StorePatch]> | null;
+        };
+        get(): T;
+        get<M extends import("./store").StoreMask<T>>(mask: M): import("./store").StorePick<T, M>;
+        set(path: import("./store").StorePath, value: any): void;
+        replace(path: import("./store").StorePath, value: any): void;
+        changed: any;
+        changedPaths: any;
+        patches?: any;
+        changedData?: any;
+    };
+    replay: {
+        func: import("../..").Listener<[StorePatch]>;
+        head: () => number;
+        getSince: (seq: number) => import("../events/replay-listen").ReplayEvent<[StorePatch]>[] | undefined;
+        line: {
+            func: import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>;
+            isRun: () => boolean;
+            run: () => void;
+            close: () => void;
+            eventClose: (cb: () => void) => () => void;
+            onClose: (cb: () => void) => () => void;
+            removeEventClose: (cb: () => void) => void;
+            on: import("../..").ListenOn<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>;
+            off: (k: (string | symbol) | import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]> | null) => void;
+            addListen: (cb: import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>, opts?: {
+                cbClose?: () => void;
+                key?: string | symbol;
+            }) => () => void;
+            removeListen: (k: (string | symbol) | import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]> | null) => void;
+            once: (cb: import("../..").Listener<[import("../events/replay-listen").ReplayEvent<[StorePatch]>]>, opts?: {
+                key?: string | symbol;
+            }) => () => void;
+            count: () => number;
+            readonly getAllKeys: (string | symbol)[];
+        };
+        hasKeyframe: boolean;
+        keyframe: () => import("../events/replay-listen").ReplayEvent<[StorePatch]> | undefined;
+        on: import("../events/replay-listen").ListenOnReplay<[StorePatch]>;
+        addListen: (cb: import("../..").Listener<[StorePatch]>, opts?: {
+            cbClose?: () => void;
+            key?: string | symbol;
+            current?: import("../..").ListenCurrent<[StorePatch]> | undefined;
+            since?: number;
+            onSeq?: (seq: number) => void;
+        }) => () => void;
+        removeListen: (k: import("../..").Listener<[StorePatch]> | (string | symbol) | null) => void;
+        once: (cb: import("../..").Listener<[StorePatch]>, opts?: {
+            key?: string | symbol;
+            current?: import("../..").ListenCurrent<[StorePatch]> | undefined;
+        }) => () => void;
+        getAllKeys: (string | symbol)[];
+        isRun: () => boolean;
+        run: () => void;
+        close: () => void;
+        eventClose: (cb: () => void) => () => void;
+        onClose: (cb: () => void) => () => void;
+        removeEventClose: (cb: () => void) => void;
+        off: (k: (string | symbol) | import("../..").Listener<[StorePatch]> | null) => void;
+        count: () => number;
+    };
+    close: () => void;
+};
+export declare function syncStoreReplay<T extends object>(store: Store<T>, remote: ReplayRemote<[StorePatch]>, opts?: ReplaySubscribeOpts): (() => void) & {
+    ready: Promise<void>;
+    seq: () => number;
+};
+export declare function storeReplayAt<T extends object>(storage: ReplayStorage<[StorePatch]>, at?: {
+    seq?: number;
+    ts?: number;
+}): T | undefined;

package/lib/Common/ObserveAll2/store-replay.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.storePatchKey = storePatchKey;
+exports.exposeStoreReplay = exposeStoreReplay;
+exports.syncStoreReplay = syncStoreReplay;
+exports.storeReplayAt = storeReplayAt;
+const store_1 = require("./store");
+const replay_listen_1 = require("../events/replay-listen");
+const replay_wire_1 = require("../events/replay-wire");
+const replay_history_1 = require("../events/replay-history");
+function makeStorePatch(store, path) {
+    let node = store.node;
+    for (const k of path)
+        node = node.at(k);
+    const exists = node.has();
+    return { path: [...path], exists, value: exists ? node.snapshot() : undefined };
+}
+function storePatchKey(patch) {
+    for (const k of patch.path)
+        if (typeof k == 'symbol')
+            return null;
+    return JSON.stringify(patch.path);
+}
+function exposeStoreReplay(store, opts = {}) {
+    const [emitPatch, lineApi] = (0, replay_listen_1.UseReplayListen)({
+        current: () => [{ path: [], exists: true, value: store.snapshot() }],
+        history: opts.getSince ? undefined : (opts.history ?? 1024),
+        getSince: opts.getSince,
+        onJournal: opts.onJournal,
+        now: opts.now,
+    });
+    const offStore = store.listenPaths().on(function journalStoreChange(change) {
+        for (const path of change.paths)
+            emitPatch(makeStorePatch(store, path));
+    });
+    return {
+        api: { ...(0, store_1.exposeStore)(store), replay: (0, replay_wire_1.exposeReplay)(lineApi) },
+        replay: lineApi,
+        close: () => { offStore(); },
+    };
+}
+function syncStoreReplay(store, remote, opts = {}) {
+    return (0, replay_wire_1.replaySubscribe)(remote, function applyLine(patch) { (0, store_1.applyStorePatch)(store, patch); }, opts);
+}
+function storeReplayAt(storage, at = {}) {
+    const envelopes = (0, replay_history_1.openHistory)(storage).at(at);
+    if (!envelopes)
+        return undefined;
+    const scratch = (0, store_1.createStore)({});
+    for (const ev of envelopes)
+        (0, store_1.applyStorePatch)(scratch, ev.event[0]);
+    return scratch.snapshot();
+}

package/lib/Common/ObserveAll2/store.d.ts

@@ -1,4 +1,4 @@
-import { listenUpdate, reactive } from "./reactive2";
+import { listenUpdate, listenUpdatePaths, reactive, ReactiveChange } from "./reactive2";
 export type StorePath = readonly PropertyKey[];
 export type StoreDrain = "micro" | "immediate" | number | ((flush: () => void) => void);
 export type StoreSubOpts = {
@@ -6,6 +6,23 @@ export type StoreSubOpts = {
     drain?: StoreDrain;
     key?: string;
 };
+export type StoreChange = ReactiveChange;
+export type StorePatch = {
+    path: PropertyKey[];
+    value: any;
+    exists: boolean;
+};
+export type StoreChangedData<M = any> = {
+    mask: M;
+    data: any;
+};
+export type StoreSyncOpts = StoreSubOpts & {
+    partial?: boolean;
+    onError?: (error: any) => void;
+};
+export type StoreExposeOpts = {
+    push?: boolean;
+};
 export type StoreCtx<T = any> = {
     store: Store<any>;
     node: StoreNode<T>;
@@ -60,39 +77,34 @@ export type Store<T extends object> = {
     once(cb: (value: T, ctx: StoreCtx<T>) => void, opts?: StoreSubOpts): () => void;
     update<M extends StoreMask<T>>(mask: M, opts?: StoreSubOpts): StoreSelection<T, M>;
     listen(): ReturnType<typeof listenUpdate>;
+    listenPaths(): ReturnType<typeof listenUpdatePaths>;
     count(): number;
 };
 type RemoteStore<T extends object> = {
     get(mask?: any): T | Promise<T>;
     changed: any;
+    changedPaths?: any;
+    patches?: any;
+    changedData?: any;
 };
-export declare function createStore<T extends object>(initial: T, opts?: Parameters<typeof reactive<T>>[1]): Store<T>;
-export declare function exposeStore<T extends object>(store: Store<T>): {
-    get: (mask?: StoreMask<T>) => T extends object ? T | { [K in (string | number | symbol) & keyof T]: T[K] | (NonNullable<T[K]> extends object ? T[K] | { [K_2 in (string | number | symbol) & keyof NonNullable<T[K]>]: NonNullable<T[K]>[K_2] | (NonNullable<NonNullable<T[K]>[K_2]> extends object ? NonNullable<T[K]>[K_2] | { [K_3 in (string | number | symbol) & keyof NonNullable<NonNullable<T[K]>[K_2]>]: NonNullable<NonNullable<T[K]>[K_2]>[K_3] | (NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]> extends object ? NonNullable<NonNullable<T[K]>[K_2]>[K_3] | { [K_4 in (string | number | symbol) & keyof NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>]: NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4] | (NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]> extends object ? NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4] | { [K_5 in (string | number | symbol) & keyof NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>]: NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5] | (NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]> extends object ? NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5] | { [K_6 in (string | number | symbol) & keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>]: NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6] | (NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]> extends object ? NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6] | { [K_7 in (string | number | symbol) & keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>]: NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7] | (NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]> extends object ? NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7] | { [K_8 in (string | number | symbol) & keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>]: NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8] | (NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]> extends object ? NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8] | { [K_9 in (string | number | symbol) & keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>]: NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9] | (NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]> extends object ? NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9] | { [K_10 in (string | number | symbol) & keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]>]: NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]>[K_10] | (NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]>[K_10]> extends object ? NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]>[K_10] | { [K_11 in (string | number | symbol) & keyof NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]>[K_10]>]: NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]>[K_10]>[K_11] | any; } : NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]>[K_10]); } : NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]>[K_9]); } : NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]>[K_8]); } : NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]>[K_7]); } : NonNullable<NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]>[K_6]); } : NonNullable<NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]>[K_5]); } : NonNullable<NonNullable<NonNullable<T[K]>[K_2]>[K_3]>[K_4]); } : NonNullable<NonNullable<T[K]>[K_2]>[K_3]); } : NonNullable<T[K]>[K_2]); } : T[K]); } : T;
-    set: (path: StorePath, value: any) => void;
-    replace: (path: StorePath, value: any) => void;
-    changed: {
-        func: import("../events/Listen3").Listener<[]>;
-        isRun: () => boolean;
-        run: () => void;
-        close: () => void;
-        eventClose: (cb: () => void) => () => void;
-        onClose: (cb: () => void) => () => void;
-        removeEventClose: (cb: () => void) => void;
-        on: import("../events/Listen3").ListenOn<[]>;
-        addListen: (cb: import("../events/Listen3").Listener<[]>, opts?: {
-            cbClose?: () => void;
-            key?: string | symbol;
-        }) => () => void;
-        removeListen: (k: (string | symbol) | import("../events/Listen3").Listener<[]> | null) => void;
-        once: (cb: import("../events/Listen3").Listener<[]>, opts?: {
-            key?: string | symbol;
-        }) => () => void;
-        count: () => number;
-        readonly getAllKeys: (string | symbol)[];
-    };
+export type StoreRemoteApi<T extends object> = {
+    get(): T;
+    get<M extends StoreMask<T>>(mask: M): StorePick<T, M>;
+    set(path: StorePath, value: any): void;
+    replace(path: StorePath, value: any): void;
+    changed: any;
+    changedPaths: any;
+    patches?: any;
+    changedData?: any;
 };
+export declare function applyStoreMask<T extends object>(store: Store<T>, mask: StoreMask<T> | any, data: any): void;
+export declare function applyStorePatch<T extends object>(store: Store<T>, patch: StorePatch): void;
+export declare function applyStorePatches<T extends object>(store: Store<T>, patches: readonly StorePatch[]): void;
+export declare function createStore<T extends object>(initial: T, opts?: Parameters<typeof reactive<T>>[1]): Store<T>;
+export declare function exposeStore<T extends object>(store: Store<T>, opts?: StoreExposeOpts): StoreRemoteApi<T>;
 export declare function createStoreMirror<T extends object>(remote: RemoteStore<T>, initial?: T, opts?: Parameters<typeof createStore<T>>[1]): Store<T> & {
-    sync: <M extends StoreMask<T>>(mask: M, subOpts?: StoreSubOpts) => Promise<() => void>;
+    sync: <M extends StoreMask<T>>(mask: M, subOpts?: StoreSyncOpts) => Promise<() => void>;
+    syncPatches: <M extends StoreMask<T>>(mask: M, subOpts?: StoreSyncOpts) => Promise<() => void>;
+    syncChangedData: <M extends StoreMask<T>>(mask: M, subOpts?: StoreSyncOpts) => Promise<() => void>;
 };
 export {};