wenay-common2 1.0.58 → 1.0.62

package/README.md

@@ -18,13 +18,13 @@ A set of common utilities and components for TypeScript/Node.js projects.
 
 ### ⏱️ **async/** — Async Utilities
 - **`waitRun.ts`** — throttle/debounce (`enhancedWaitRun`), async queues (`createAsyncQueue`, `queueRun`), task queue with readiness control (`createTaskQueue`)
-- **`PromiseArrayListen.ts`** — processing an array of promises with success/error subscriptions
+- **`promiseProgress.ts`** — processing an array of promises with success/error subscriptions
 - **`createIterableObject.ts`** — proxy for iterable objects (readonly/read-write)
 
 ### 🔔 **events/** — Events and Subscriptions
-- **`Listen.ts`** — subscription system (`UseListen`, `funcListenCallback`), `isListenCallback` check
+- **`Listen.ts`** — subscription system (`listen`, `createListen`), `isListenCallback` check
 - **`event.ts`** — event handler collections (`CObjectEventsArr`, `CObjectEventsList`)
-- **`SocketBuffer.ts`** — socket callback buffering (`socketBuffer3`, `funcListenCallbackSnapshot`)
+- **`SocketBuffer.ts`** — socket callback buffering (`socketBuffer`, `listenSnapshot`)
 - **`SocketServerHook.ts`** — tag-based subscription wrappers for socket communication (`SocketServerHook`, `WebSocketServerHook`)
 - **`joinListens.ts`** — merging multiple subscription streams into one (`joinListens`)
 - **`listen-socket.ts`** — bridge between event system and RPC (`listenSocket`, `listenSocketFirst`, `listenSocketAll`, `listenSocketSmart`)
@@ -92,11 +92,11 @@ Bidirectional, strongly-typed RPC protocol over sockets (Socket.IO or similar).
 
 ### 2.1 Socket Connection
 ```typescript
-import { createRpcServerAuto, UseListen } from "wenay-common2";
+import { createRpcServerAuto, listen } from "wenay-common2";
 
 io.sockets.on('connection', (socket) => {
   // 1. Create unsubscribe trigger for memory cleanup
-  const [stop, listenStop] = UseListen<[]>();
+  const [stop, listenStop] = listen<[]>();
   socket.on('disconnect', stop);
 
   // 2. Initialize RPC channel on this socket
@@ -113,10 +113,10 @@ io.sockets.on('connection', (socket) => {
 ### 2.2 Building API Object (Facade)
 The object is traversed by the server to build a "Schema" that is sent to the client.
 ```typescript
-import { noStrict, UseListen } from "wenay-common2";
+import { noStrict, listen } from "wenay-common2";
 
 // Create pub/sub event system
-const [sendEvent, listenEvent] = UseListen<[string]>();
+const [sendEvent, listenEvent] = listen<[string]>();
 
 export function buildFacade(client) {
   const role = (...roles) => hasRole(client, roles) ? true : null;
@@ -233,7 +233,7 @@ api.space.admin.logAction("clicked");
 ```
 
 ### 3.4 Client Subscriptions (Listen)
-`createRpcServerAuto` exposes server `UseListen` values as RPC Listen nodes. New code uses `on`/`once` and keeps the returned `off` handle. For TypeScript, project `client.func` to `DeepSocketListen<ServerFacade>`; this mirrors the runtime shape and keeps event argument types.
+`createRpcServerAuto` exposes server `listen` values as RPC Listen nodes. New code uses `on`/`once` and keeps the returned `off` handle. For TypeScript, project `client.func` to `DeepSocketListen<ServerFacade>`; this mirrors the runtime shape and keeps event argument types.
 ```typescript
 import type { DeepSocketListen } from "wenay-common2";
 

package/lib/Common/{ObserveAll2 → Observe}/index.d.ts

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

package/lib/Common/{ObserveAll2 → Observe}/index.js

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./reactive2"), exports);
 __exportStar(require("./store"), exports);
 __exportStar(require("./store-replay"), exports);
+__exportStar(require("./store-offline"), exports);

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

@@ -0,0 +1,21 @@
+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;
+    depth?: number;
+    eager?: boolean;
+};
+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): import("../events/Listen3").ListenApi<[]>;
+export declare function listenUpdatePaths(p: any): import("../events/Listen3").ListenApi<[ReactiveChange]>;
+export type Reactive<T extends object> = T;
+export {};

package/lib/Common/{ObserveAll2 → Observe}/reactive2.js

@@ -351,22 +351,22 @@ function flushReactive(p) {
     return new Promise(resolve => { eng.waiters.add(resolve); });
 }
 function listenUpdate(p) {
-    const listen = (0, Listen_1.funcListenCallbackBase)((emit) => onUpdate(p, () => emit()), {
+    const listen = (0, Listen_1.createListen)((emit) => onUpdate(p, () => emit()), {
         event: (type, count, api) => {
-            if (type == "add" && count == 1 && !api.isRun())
+            if (type == "add" && count == 1 && !api.isRunning())
                 api.run();
-            if (type == "remove" && count == 0 && api.isRun())
+            if (type == "remove" && count == 0 && api.isRunning())
                 api.close();
         },
     });
     return listen;
 }
 function listenUpdatePaths(p) {
-    const listen = (0, Listen_1.funcListenCallbackBase)((emit) => onUpdatePaths(p, change => emit(change)), {
+    const listen = (0, Listen_1.createListen)((emit) => onUpdatePaths(p, change => emit(change)), {
         event: (type, count, api) => {
-            if (type == "add" && count == 1 && !api.isRun())
+            if (type == "add" && count == 1 && !api.isRunning())
                 api.run();
-            if (type == "remove" && count == 0 && api.isRun())
+            if (type == "remove" && count == 0 && api.isRunning())
                 api.close();
         },
     });

package/lib/Common/Observe/store-offline.d.ts

@@ -0,0 +1,88 @@
+import { ReplayRemote, ReplaySubscribeOpts } from '../events/replay-wire';
+import { createStore, Store, StorePatch } from './store';
+export type OfflineStorage = {
+    read<T>(key: string): Promise<T | undefined>;
+    write<T>(key: string, value: T): Promise<void>;
+    remove(key: string): Promise<void>;
+    transaction?<R>(fn: (tx: OfflineStorage) => Promise<R>): Promise<R>;
+};
+export type OfflineStoreRecord<T extends object> = {
+    version: number;
+    seq: number;
+    snapshot: T;
+    savedAt: number;
+};
+export type OfflineStoreStatus = {
+    ready: boolean;
+    syncing: boolean;
+    offline: boolean;
+    stale: boolean;
+    saving: boolean;
+    seq: number;
+    savedAt?: number;
+    error?: unknown;
+};
+export type PersistStoreOpts = {
+    key: string;
+    storage: OfflineStorage;
+    version?: number;
+    seq?: number;
+    savedAt?: number;
+    debounceMs?: number;
+    now?: () => number;
+    onError?: (error: unknown) => void;
+    onStatus?: (status: OfflineStoreStatus) => void;
+};
+export type CreateOfflineStoreOpts<T extends object> = {
+    key: string;
+    remote?: ReplayRemote<[StorePatch]>;
+    initial: T;
+    storage: OfflineStorage;
+    version?: number;
+    debounceMs?: number;
+    mode?: 'snapshot' | 'topLevel';
+    migrate?: (oldSnapshot: unknown, fromVersion: number, toVersion: number) => T | Promise<T>;
+    now?: () => number;
+    storeOpts?: Parameters<typeof createStore<T>>[1];
+    syncOpts?: ReplaySubscribeOpts;
+    onError?: (error: unknown) => void;
+    onStatus?: (status: OfflineStoreStatus) => void;
+};
+export type PersistedStoreControl = ReturnType<typeof persistStore>;
+export type OfflineStore<T extends object> = Store<T> & {
+    ready: Promise<void>;
+    close(): void;
+    flush(): Promise<void>;
+    status(): OfflineStoreStatus;
+    statusListen: PersistedStoreControl['statusListen'];
+    reconnect(remote: ReplayRemote<[StorePatch]>, opts?: ReplaySubscribeOpts): Promise<void>;
+};
+export declare function createMemoryOfflineStorage(initial?: Record<string, unknown>): OfflineStorage & {
+    dump(): Record<string, unknown>;
+};
+export declare function persistStore<T extends object>(store: Store<T>, opts: PersistStoreOpts): {
+    flush: () => Promise<void>;
+    forceFlush: () => Promise<void>;
+    close: () => void;
+    setSeq: (nextSeq: number) => void;
+    seq: () => number;
+    status: () => OfflineStoreStatus;
+    statusListen: {
+        on: import("../events/Listen3").ListenOnCurrent<[OfflineStoreStatus]>;
+        once: (cb: import("../events/Listen3").Listener<[OfflineStoreStatus]>, opts?: {
+            key?: import("../events/Listen3").ListenKey;
+            current?: import("../events/Listen3").ListenCurrent<[OfflineStoreStatus]> | undefined;
+        }) => import("../events/Listen3").ListenOff;
+        emit: import("../events/Listen3").Listener<[OfflineStoreStatus]>;
+        has(key: import("../events/Listen3").ListenKey): boolean;
+        off(keyOrCallback: import("../events/Listen3").ListenKey | import("../events/Listen3").Listener<[OfflineStoreStatus]> | null): void;
+        close(): void;
+        count(): number;
+        keys(): import("../events/Listen3").ListenKey[];
+        isRunning(): boolean;
+        run(): void;
+        onClose(cb: () => void): import("../events/Listen3").ListenOff;
+    };
+    setSyncStatus: (patch: Partial<OfflineStoreStatus>) => void;
+};
+export declare function createOfflineStore<T extends object>(opts: CreateOfflineStoreOpts<T>): Promise<OfflineStore<T>>;

package/lib/Common/Observe/store-offline.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMemoryOfflineStorage = createMemoryOfflineStorage;
+exports.persistStore = persistStore;
+exports.createOfflineStore = createOfflineStore;
+const common_1 = require("../core/common");
+const Listen3_1 = require("../events/Listen3");
+const store_1 = require("./store");
+const store_replay_1 = require("./store-replay");
+function isRecord(v) {
+    return !!v && typeof v == 'object' && typeof v.version == 'number'
+        && typeof v.seq == 'number' && 'snapshot' in v;
+}
+function cloneValue(value) {
+    return (0, common_1.clone)(value);
+}
+function createMemoryOfflineStorage(initial) {
+    const data = new Map();
+    for (const [k, v] of Object.entries(initial ?? {}))
+        data.set(k, cloneValue(v));
+    const api = {
+        async read(key) {
+            return data.has(key) ? cloneValue(data.get(key)) : undefined;
+        },
+        async write(key, value) {
+            data.set(key, cloneValue(value));
+        },
+        async remove(key) {
+            data.delete(key);
+        },
+        async transaction(fn) {
+            return fn(api);
+        },
+        dump() {
+            const out = {};
+            for (const [k, v] of data)
+                out[k] = cloneValue(v);
+            return out;
+        },
+    };
+    return api;
+}
+function emitError(opts, error) {
+    if (opts.onError)
+        opts.onError(error);
+    else
+        setTimeout(function rethrowOfflineStoreError() { throw error; }, 0);
+}
+function copyStatus(status) {
+    return { ...status };
+}
+function persistStore(store, opts) {
+    const { key, storage, version = 1, debounceMs = 250, now = Date.now, onStatus } = opts;
+    let seq = opts.seq ?? -1;
+    let savedAt = opts.savedAt;
+    let closed = false;
+    let dirty = false;
+    let timer = null;
+    let chain = Promise.resolve();
+    const status = {
+        ready: true,
+        syncing: false,
+        offline: false,
+        stale: false,
+        saving: false,
+        seq,
+        savedAt,
+    };
+    const [emitStatus, statusListen] = (0, Listen3_1.listenStore)({
+        current: () => [copyStatus(status)],
+    });
+    function updateStatus(patch = {}) {
+        Object.assign(status, patch, { seq, savedAt });
+        const snap = copyStatus(status);
+        emitStatus(snap);
+        onStatus?.(snap);
+    }
+    function clearTimer() {
+        if (timer)
+            clearTimeout(timer);
+        timer = null;
+    }
+    function scheduleSave() {
+        if (closed)
+            return;
+        dirty = true;
+        clearTimer();
+        timer = setTimeout(function flushOfflineStoreTimer() {
+            timer = null;
+            flush().catch(e => emitError(opts, e));
+        }, Math.max(0, debounceMs));
+        timer.unref?.();
+    }
+    async function writeRecord(record) {
+        if (storage.transaction) {
+            await storage.transaction(async function writeOfflineStoreTx(tx) {
+                await tx.write(key, record);
+            });
+        }
+        else {
+            await storage.write(key, record);
+        }
+    }
+    async function runFlush(force = false) {
+        if (closed)
+            return;
+        if (!dirty && !force)
+            return;
+        dirty = false;
+        updateStatus({ saving: true, error: undefined });
+        const nextSavedAt = now();
+        const record = {
+            version,
+            seq,
+            snapshot: store.snapshot(),
+            savedAt: nextSavedAt,
+        };
+        try {
+            await writeRecord(record);
+            savedAt = nextSavedAt;
+            updateStatus({ saving: false, error: undefined });
+        }
+        catch (e) {
+            updateStatus({ saving: false, error: e });
+            throw e;
+        }
+        finally {
+            if (dirty && !closed)
+                scheduleSave();
+        }
+    }
+    function flush() {
+        clearTimer();
+        const task = chain.catch(() => { }).then(function flushOfflineStore() { return runFlush(false); });
+        chain = task.catch(() => { });
+        return task;
+    }
+    function forceFlush() {
+        clearTimer();
+        dirty = true;
+        const task = chain.catch(() => { }).then(function forceFlushOfflineStore() { return runFlush(true); });
+        chain = task.catch(() => { });
+        return task;
+    }
+    function setSeq(nextSeq) {
+        if (nextSeq == seq)
+            return;
+        seq = nextSeq;
+        updateStatus();
+        scheduleSave();
+    }
+    const offStore = store.listenPaths().on(function persistStoreChange() {
+        scheduleSave();
+    });
+    function close() {
+        if (closed)
+            return;
+        closed = true;
+        clearTimer();
+        offStore();
+        statusListen.close();
+    }
+    function setSyncStatus(patch) {
+        updateStatus(patch);
+    }
+    return {
+        flush,
+        forceFlush,
+        close,
+        setSeq,
+        seq: () => seq,
+        status: () => copyStatus(status),
+        statusListen,
+        setSyncStatus,
+    };
+}
+async function loadSnapshot(opts) {
+    const { key, storage, initial, version = 1, migrate } = opts;
+    const raw = await storage.read(key);
+    if (raw == null)
+        return { snapshot: initial, seq: -1 };
+    if (isRecord(raw)) {
+        if (raw.version == version)
+            return { snapshot: raw.snapshot, seq: raw.seq, savedAt: raw.savedAt };
+        if (migrate)
+            return {
+                snapshot: await migrate(raw.snapshot, raw.version, version),
+                seq: raw.seq,
+                savedAt: raw.savedAt,
+            };
+        return { snapshot: initial, seq: -1 };
+    }
+    if (migrate)
+        return { snapshot: await migrate(raw, 0, version), seq: -1 };
+    return { snapshot: initial, seq: -1 };
+}
+async function createOfflineStore(opts) {
+    const { remote, storeOpts, syncOpts = {}, onStatus } = opts;
+    if (opts.mode && opts.mode != 'snapshot')
+        throw new Error('createOfflineStore: only snapshot mode is implemented');
+    let loaded;
+    try {
+        loaded = await loadSnapshot(opts);
+    }
+    catch (e) {
+        emitError(opts, e);
+        loaded = { snapshot: opts.initial, seq: -1 };
+    }
+    const store = (0, store_1.createStore)(loaded.snapshot, storeOpts);
+    const persist = persistStore(store, {
+        key: opts.key,
+        storage: opts.storage,
+        version: opts.version,
+        seq: loaded.seq,
+        savedAt: loaded.savedAt,
+        debounceMs: opts.debounceMs,
+        now: opts.now,
+        onError: opts.onError,
+        onStatus,
+    });
+    let sub = null;
+    let ready = Promise.resolve();
+    async function reconnect(nextRemote, nextSyncOpts = syncOpts) {
+        sub?.();
+        persist.setSyncStatus({ syncing: true, offline: false, ready: false, error: undefined });
+        const { onSeq, onError, onStale, since, ...rest } = nextSyncOpts;
+        const effectiveSince = since ?? (persist.seq() >= 0 ? persist.seq() : undefined);
+        try {
+            sub = (0, store_replay_1.syncStoreReplay)(store, nextRemote, {
+                ...rest,
+                since: effectiveSince,
+                onSeq: function offlineStoreOnSeq(seq) {
+                    persist.setSeq(seq);
+                    onSeq?.(seq);
+                },
+                onError: function offlineStoreOnError(error) {
+                    persist.setSyncStatus({ offline: true, syncing: false, error });
+                    onError?.(error);
+                    if (!onError)
+                        opts.onError?.(error);
+                },
+                onStale: onStale && function offlineStoreOnStale(info) {
+                    persist.setSyncStatus({ stale: info.stale });
+                    onStale(info);
+                },
+            });
+            ready = sub.ready.then(function offlineStoreReady() {
+                persist.setSyncStatus({ ready: true, syncing: false });
+            });
+            await ready;
+        }
+        catch (e) {
+            persist.setSyncStatus({ ready: true, syncing: false, offline: true, error: e });
+            emitError(opts, e);
+        }
+    }
+    if (remote) {
+        ready = reconnect(remote);
+    }
+    else {
+        persist.setSyncStatus({ ready: true, syncing: false, offline: true });
+    }
+    function close() {
+        sub?.();
+        persist.close();
+    }
+    function flush() {
+        return persist.flush();
+    }
+    return Object.assign(store, {
+        get ready() { return ready; },
+        close,
+        flush,
+        status: persist.status,
+        statusListen: persist.statusListen,
+        reconnect,
+    });
+}

package/lib/Common/{ObserveAll2 → Observe}/store-replay.d.ts

@@ -1,4 +1,4 @@
-import { Store, StorePatch } from './store';
+import { Store, StorePatch, StoreDrain, StoreEachCtx } from './store';
 import { ReplayListenOptions, ReplayEvent } from '../events/replay-listen';
 import { ReplayRemote, ReplaySubscribeOpts } from '../events/replay-wire';
 import { ReplayStorage } from '../events/replay-history';
@@ -17,57 +17,28 @@ export declare function exposeStoreReplay<T extends object>(store: Store<T>, opt
         changedData?: any;
     };
     replay: {
-        func: import("../..").Listener<[StorePatch]>;
+        emit: import("../..").Listener<[StorePatch]>;
         head: () => number;
         isStale: () => boolean;
         lastTs: () => number;
         close: () => void;
         getSince: (seq: number) => ReplayEvent<[StorePatch]>[] | undefined;
-        line: {
-            func: import("../..").Listener<[ReplayEvent<[StorePatch]>]>;
-            isRun: () => boolean;
-            run: () => void;
-            close: () => void;
-            eventClose: (cb: () => void) => () => void;
-            onClose: (cb: () => void) => () => void;
-            removeEventClose: (cb: () => void) => void;
-            on: import("../..").ListenOn<[ReplayEvent<[StorePatch]>]>;
-            off: (k: (string | symbol) | import("../..").Listener<[ReplayEvent<[StorePatch]>]> | null) => void;
-            addListen: (cb: import("../..").Listener<[ReplayEvent<[StorePatch]>]>, opts?: {
-                cbClose?: () => void;
-                key?: string | symbol;
-            }) => () => void;
-            removeListen: (k: (string | symbol) | import("../..").Listener<[ReplayEvent<[StorePatch]>]> | null) => void;
-            once: (cb: import("../..").Listener<[ReplayEvent<[StorePatch]>]>, opts?: {
-                key?: string | symbol;
-            }) => () => void;
-            count: () => number;
-            readonly getAllKeys: (string | symbol)[];
-        };
+        line: import("../..").ListenApi<[ReplayEvent<[StorePatch]>]>;
         hasKeyframe: boolean;
         keyframe: () => ReplayEvent<[StorePatch]> | undefined;
         frame: (sinceSeq: number, hint?: unknown) => ReplayEvent<[StorePatch]>[];
         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: (string | symbol) | import("../..").Listener<[StorePatch]> | null) => void;
         once: (cb: import("../..").Listener<[StorePatch]>, opts?: {
             key?: string | symbol;
             current?: import("../..").ListenCurrent<[StorePatch]> | undefined;
         }) => () => void;
-        getAllKeys: (string | symbol)[];
-        isRun: () => boolean;
-        run: () => void;
-        eventClose: (cb: () => void) => () => void;
-        onClose: (cb: () => void) => () => void;
-        removeEventClose: (cb: () => void) => void;
-        off: (k: (string | symbol) | import("../..").Listener<[StorePatch]> | null) => void;
-        count: () => number;
+        has(key: import("../..").ListenKey): boolean;
+        off(keyOrCallback: import("../..").ListenKey | import("../..").Listener<[StorePatch]> | null): void;
+        count(): number;
+        keys(): import("../..").ListenKey[];
+        isRunning(): boolean;
+        run(): void;
+        onClose(cb: () => void): import("../..").ListenOff;
     };
     close: () => void;
 };
@@ -77,6 +48,16 @@ export declare function syncStoreReplay<T extends object>(store: Store<T>, remot
     isStale: () => boolean;
     lastTs: () => number;
 };
+export declare function syncStoreReplayEach<T extends object>(remote: ReplayRemote<[StorePatch]>, cb: (key: string, value: T[keyof T] | undefined, ctx: StoreEachCtx) => void, opts?: ReplaySubscribeOpts & {
+    drain?: StoreDrain;
+    initial?: T;
+}): (() => void) & {
+    store: Store<T>;
+    ready: Promise<void>;
+    seq: () => number;
+    isStale: () => boolean;
+    lastTs: () => number;
+};
 export declare function storeReplayAt<T extends object>(storage: ReplayStorage<[StorePatch]>, at?: {
     seq?: number;
     ts?: number;

package/lib/Common/{ObserveAll2 → Observe}/store-replay.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.storePatchKey = storePatchKey;
 exports.exposeStoreReplay = exposeStoreReplay;
 exports.syncStoreReplay = syncStoreReplay;
+exports.syncStoreReplayEach = syncStoreReplayEach;
 exports.storeReplayAt = storeReplayAt;
 const store_1 = require("./store");
 const replay_listen_1 = require("../events/replay-listen");
@@ -33,7 +34,7 @@ function condensePatchTail(tail) {
     return [...held.values()];
 }
 function exposeStoreReplay(store, opts = {}) {
-    const [emitPatch, lineApi] = (0, replay_listen_1.UseReplayListen)({
+    const [emitPatch, lineApi] = (0, replay_listen_1.replayListen)({
         current: () => [{ path: [], exists: true, value: store.snapshot() }],
         frame: condensePatchTail,
         history: opts.getSince ? undefined : (opts.history ?? 1024),
@@ -54,6 +55,20 @@ function exposeStoreReplay(store, opts = {}) {
 function syncStoreReplay(store, remote, opts = {}) {
     return (0, replay_wire_1.replaySubscribe)(remote, function applyLine(patch) { (0, store_1.applyStorePatch)(store, patch); }, opts);
 }
+function syncStoreReplayEach(remote, cb, opts = {}) {
+    const { drain, initial, ...wireOpts } = opts;
+    const store = (0, store_1.createStore)((initial ?? {}), drain !== undefined ? { drain } : {});
+    const offEach = store.each().on(cb);
+    const sub = syncStoreReplay(store, remote, wireOpts);
+    function off() { offEach(); sub(); }
+    return Object.assign(off, {
+        store,
+        ready: sub.ready,
+        seq: sub.seq,
+        isStale: sub.isStale,
+        lastTs: sub.lastTs,
+    });
+}
 function storeReplayAt(storage, at = {}) {
     const envelopes = (0, replay_history_1.openHistory)(storage).at(at);
     if (!envelopes)

package/lib/Common/{ObserveAll2 → Observe}/store.d.ts

@@ -1,3 +1,4 @@
+import { createListen } from "../events/Listen";
 import { listenUpdate, listenUpdatePaths, reactive, ReactiveChange } from "./reactive2";
 export type StorePath = readonly PropertyKey[];
 export type StoreDrain = "micro" | "immediate" | number | ((flush: () => void) => void);
@@ -67,6 +68,12 @@ export type StoreSelectionCtx<T, M> = {
     mask: M;
     paths: PropertyKey[][];
 };
+export type StoreEachOpts = {
+    depth?: number;
+};
+export type StoreEachCtx = {
+    path: PropertyKey[];
+};
 export type Store<T extends object> = {
     readonly state: T;
     readonly node: StoreNode<T>;
@@ -76,6 +83,7 @@ export type Store<T extends object> = {
     on(cb: (value: T, ctx: StoreCtx<T>) => void, opts?: StoreSubOpts): () => void;
     once(cb: (value: T, ctx: StoreCtx<T>) => void, opts?: StoreSubOpts): () => void;
     update<M extends StoreMask<T>>(mask: M, opts?: StoreSubOpts): StoreSelection<T, M>;
+    each(opts?: StoreEachOpts): ReturnType<typeof createListen<[key: string, value: T[keyof T] | undefined, ctx: StoreEachCtx]>>;
     listen(): ReturnType<typeof listenUpdate>;
     listenPaths(): ReturnType<typeof listenUpdatePaths>;
     count(): number;