wenay-common2 1.0.61 → 1.0.63

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/Observe/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./reactive";
+export * from "./store";
+export * from "./store-replay";
+export * from "./store-offline";
+export * from "./store-manager";

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

@@ -14,6 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./reactive2"), exports);
+__exportStar(require("./reactive"), exports);
 __exportStar(require("./store"), exports);
 __exportStar(require("./store-replay"), exports);
+__exportStar(require("./store-offline"), exports);
+__exportStar(require("./store-manager"), exports);

package/lib/Common/Observe/reactive.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/Listen").ListenApi<[]>;
+export declare function listenUpdatePaths(p: any): import("../events/Listen").ListenApi<[ReactiveChange]>;
+export type Reactive<T extends object> = T;
+export {};

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

@@ -9,7 +9,7 @@ exports.flushReactive = flushReactive;
 exports.listenUpdate = listenUpdate;
 exports.listenUpdatePaths = listenUpdatePaths;
 const Listen_1 = require("../events/Listen");
-const NODE = Symbol('reactive2.node');
+const NODE = Symbol('reactive.node');
 const isObj = (v) => v != null && typeof v == 'object';
 const isReactiveObj = (v) => {
     if (!isObj(v))
@@ -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/reactive2.d.ts

@@ -0,0 +1 @@
+export * from './reactive';

package/lib/Common/{events/Listen2.js → Observe/reactive2.js}

@@ -14,4 +14,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Listen3"), exports);
+__exportStar(require("./reactive"), exports);

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

@@ -0,0 +1,123 @@
+import { ReplayRemote, ReplaySubscribeOpts } from '../events/replay-wire';
+import { createStore, Store, StoreMask, StorePatch, StoreSyncOpts } from './store';
+import { OfflineStorage, OfflineStore } from './store-offline';
+type RemoteStore<T extends object> = {
+    get(mask?: any): T | Promise<T>;
+    changed: any;
+    changedPaths?: any;
+    patches?: any;
+    changedData?: any;
+};
+export type StoreMirror<T extends object> = Store<T> & {
+    sync<M extends StoreMask<T>>(mask: M, opts?: StoreSyncOpts): Promise<() => void>;
+    syncPatches<M extends StoreMask<T>>(mask: M, opts?: StoreSyncOpts): Promise<() => void>;
+    syncChangedData<M extends StoreMask<T>>(mask: M, opts?: StoreSyncOpts): Promise<() => void>;
+};
+export type ManagedStoreKind = 'mirror' | 'replay' | 'offline';
+export type ManagedStoreState = 'idle' | 'starting' | 'ready' | 'stopped' | 'error';
+export type ManagedStoreSyncMode = 'pull' | 'patches' | 'changedData';
+export type ManagedStoreUsage = {
+    count: number;
+    weight: number;
+    lastUsedAt?: number;
+};
+export type ManagedStorePriorityContext = {
+    key: string;
+    now: number;
+    usage?: ManagedStoreUsage;
+};
+type CommonResource<T extends object> = {
+    key?: string;
+    initial: T;
+    tags?: readonly string[];
+    priority?: number | ((ctx: ManagedStorePriorityContext) => number);
+    usageKey?: string;
+    explicitOnly?: boolean;
+    large?: boolean;
+    autoStart?: boolean;
+    storeOpts?: Parameters<typeof createStore<T>>[1];
+};
+export type ManagedMirrorResource<T extends object> = CommonResource<T> & {
+    kind?: 'mirror';
+    remote: RemoteStore<T>;
+    mask: StoreMask<T>;
+    sync?: {
+        mode?: ManagedStoreSyncMode;
+        opts?: StoreSyncOpts;
+    };
+};
+export type ManagedReplayResource<T extends object> = CommonResource<T> & {
+    kind?: 'replay';
+    remote: ReplayRemote<[StorePatch]>;
+    syncOpts?: ReplaySubscribeOpts;
+};
+export type ManagedOfflineResource<T extends object> = CommonResource<T> & {
+    kind?: 'offline';
+    remote?: ReplayRemote<[StorePatch]>;
+    storage: OfflineStorage;
+    storageKey?: string;
+    version?: number;
+    debounceMs?: number;
+    syncOpts?: ReplaySubscribeOpts;
+    migrate?: (oldSnapshot: unknown, fromVersion: number, toVersion: number) => T | Promise<T>;
+};
+export type ManagedStoreResource<T extends object = any> = ManagedMirrorResource<T> | ManagedReplayResource<T> | ManagedOfflineResource<T>;
+export type ManagedStoreResources = Record<string, ManagedStoreResource<any>>;
+export type ManagedStoreOf<R> = R extends ManagedOfflineResource<infer T> ? OfflineStore<T> : R extends ManagedReplayResource<infer T> ? Store<T> : R extends ManagedMirrorResource<infer T> ? StoreMirror<T> : never;
+export type ManagedStoreStatus = {
+    key: string;
+    state: ManagedStoreState;
+    kind: ManagedStoreKind;
+    error?: unknown;
+    startedAt?: number;
+    stoppedAt?: number;
+};
+export type ManagedStorePlanItem = {
+    key: string;
+    kind: ManagedStoreKind;
+    score: number;
+    state: ManagedStoreState;
+    large: boolean;
+    explicitOnly: boolean;
+    tags: readonly string[];
+};
+export type ManagedStoreStartOpts = {
+    explicit?: boolean;
+    reason?: string;
+};
+export type ManagedStorePlanOpts = {
+    keys?: Iterable<string>;
+    tags?: readonly string[];
+    includeLarge?: boolean;
+    includeExplicit?: boolean;
+    limit?: number;
+    now?: number;
+};
+export type ManagedStoreHandle<TStore> = {
+    readonly key: string;
+    readonly kind: ManagedStoreKind;
+    start(opts?: ManagedStoreStartOpts): Promise<TStore>;
+    stop(): void;
+    get(): TStore | undefined;
+    status(): ManagedStoreStatus;
+    touch(weight?: number): void;
+};
+export declare const managedStore: {
+    mirror<T extends object>(resource: ManagedMirrorResource<T>): ManagedMirrorResource<T>;
+    replay<T extends object>(resource: ManagedReplayResource<T>): ManagedReplayResource<T>;
+    offline<T extends object>(resource: ManagedOfflineResource<T>): ManagedOfflineResource<T>;
+};
+export declare function createStoreManager<const R extends ManagedStoreResources>(resources: R): {
+    handles: { [K in keyof R]: ManagedStoreHandle<ManagedStoreOf<R[K]>>; };
+    statusListen: import("../events/Listen").ListenApi<[ManagedStoreStatus]>;
+    plan: (opts?: ManagedStorePlanOpts) => ManagedStorePlanItem[];
+    start: <K extends keyof R & string>(key: K, opts?: ManagedStoreStartOpts) => Promise<ManagedStoreOf<R[K]>>;
+    startMany: (keys: Iterable<keyof R & string>, opts?: ManagedStoreStartOpts) => Promise<Partial<{ [K in keyof R]: ManagedStoreOf<R[K]>; }>>;
+    startPlanned: (opts?: ManagedStorePlanOpts & ManagedStoreStartOpts) => Promise<Partial<{ [K in keyof R]: ManagedStoreOf<R[K]>; }>>;
+    stop: <K extends keyof R & string>(key: K) => void;
+    stopAll: () => void;
+    get: <K extends keyof R & string>(key: K) => ManagedStoreOf<R[K]> | undefined;
+    touch: <K extends keyof R & string>(key: K, weight?: number) => void;
+    usage: () => Map<string, ManagedStoreUsage>;
+};
+export {};

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

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.managedStore = void 0;
+exports.createStoreManager = createStoreManager;
+const Listen_1 = require("../events/Listen");
+const store_1 = require("./store");
+const store_offline_1 = require("./store-offline");
+const store_replay_1 = require("./store-replay");
+function kindOf(resource) {
+    return resource.kind ?? 'mirror';
+}
+function hasAnyTag(resourceTags, tags) {
+    if (!tags?.length)
+        return true;
+    if (!resourceTags?.length)
+        return false;
+    return tags.some(tag => resourceTags.includes(tag));
+}
+function resourceScore(key, resource, usage, now) {
+    const base = typeof resource.priority == 'function'
+        ? resource.priority({ key, usage, now })
+        : resource.priority ?? 0;
+    const usageScore = usage ? usage.weight + Math.min(usage.count, 50) : 0;
+    const recency = usage?.lastUsedAt ? Math.max(0, 1_000_000 - (now - usage.lastUsedAt)) / 1_000_000 : 0;
+    return base + usageScore + recency;
+}
+exports.managedStore = {
+    mirror(resource) {
+        return { ...resource, kind: 'mirror' };
+    },
+    replay(resource) {
+        return { ...resource, kind: 'replay' };
+    },
+    offline(resource) {
+        return { ...resource, kind: 'offline' };
+    },
+};
+function createStoreManager(resources) {
+    const usages = new Map();
+    const [emitStatus, statusListen] = (0, Listen_1.listen)();
+    function usageFor(key, resource) {
+        const usageKey = resource.usageKey ?? key;
+        let usage = usages.get(usageKey);
+        if (!usage) {
+            usage = { count: 0, weight: 0 };
+            usages.set(usageKey, usage);
+        }
+        return usage;
+    }
+    function createHandle(key, resource) {
+        const kind = kindOf(resource);
+        let state = 'idle';
+        let store;
+        let stopSync;
+        let pending;
+        let error;
+        let startedAt;
+        let stoppedAt;
+        function setState(next, nextError) {
+            state = next;
+            error = nextError;
+            if (next == 'ready')
+                startedAt = Date.now();
+            if (next == 'stopped')
+                stoppedAt = Date.now();
+            emitStatus(status());
+        }
+        function status() {
+            return { key, state, kind, error, startedAt, stoppedAt };
+        }
+        async function start(opts = {}) {
+            if (resource.explicitOnly && !opts.explicit) {
+                throw new Error(`store manager: ${key} is explicitOnly`);
+            }
+            if (state == 'ready' && store)
+                return store;
+            if (pending)
+                return pending;
+            pending = (async () => {
+                setState('starting');
+                try {
+                    if (kind == 'mirror') {
+                        const r = resource;
+                        store ??= (0, store_1.createStoreMirror)(r.remote, r.initial, r.storeOpts);
+                        const mode = r.sync?.mode ?? 'pull';
+                        const opts = r.sync?.opts;
+                        stopSync = mode == 'patches'
+                            ? await store.syncPatches(r.mask, opts)
+                            : mode == 'changedData'
+                                ? await store.syncChangedData(r.mask, opts)
+                                : await store.sync(r.mask, opts);
+                    }
+                    else if (kind == 'replay') {
+                        const r = resource;
+                        store ??= (0, store_1.createStore)(r.initial, r.storeOpts);
+                        const sub = (0, store_replay_1.syncStoreReplay)(store, r.remote, r.syncOpts);
+                        stopSync = sub;
+                        await sub.ready;
+                    }
+                    else {
+                        const r = resource;
+                        store = await (0, store_offline_1.createOfflineStore)({
+                            key: r.storageKey ?? key,
+                            remote: r.remote,
+                            initial: r.initial,
+                            storage: r.storage,
+                            version: r.version,
+                            debounceMs: r.debounceMs,
+                            storeOpts: r.storeOpts,
+                            syncOpts: r.syncOpts,
+                            migrate: r.migrate,
+                        });
+                        await store.ready;
+                    }
+                    setState('ready');
+                    return store;
+                }
+                catch (e) {
+                    setState('error', e);
+                    throw e;
+                }
+                finally {
+                    pending = undefined;
+                }
+            })();
+            return pending;
+        }
+        function stop() {
+            stopSync?.();
+            stopSync = undefined;
+            if (kind == 'offline') {
+                store?.close?.();
+                store = undefined;
+            }
+            if (state != 'idle')
+                setState('stopped');
+        }
+        function touch(weight = 1) {
+            const usage = usageFor(key, resource);
+            usage.count++;
+            usage.weight += weight;
+            usage.lastUsedAt = Date.now();
+        }
+        return { key, kind, start, stop, get: () => store, status, touch };
+    }
+    const handles = {};
+    for (const key of Object.keys(resources))
+        handles[key] = createHandle(key, resources[key]);
+    function plan(opts = {}) {
+        const now = opts.now ?? Date.now();
+        const keySet = opts.keys ? new Set([...opts.keys].map(String)) : null;
+        const out = [];
+        for (const key of Object.keys(resources)) {
+            if (keySet && !keySet.has(key))
+                continue;
+            const resource = resources[key];
+            if (!hasAnyTag(resource.tags, opts.tags))
+                continue;
+            if (resource.explicitOnly && !opts.includeExplicit)
+                continue;
+            if (resource.large && !opts.includeLarge)
+                continue;
+            const usage = usages.get(resource.usageKey ?? key);
+            out.push({
+                key,
+                kind: kindOf(resource),
+                score: resourceScore(key, resource, usage, now),
+                state: handles[key].status().state,
+                large: !!resource.large,
+                explicitOnly: !!resource.explicitOnly,
+                tags: resource.tags ?? [],
+            });
+        }
+        out.sort((a, b) => b.score - a.score || a.key.localeCompare(b.key));
+        return opts.limit == null ? out : out.slice(0, opts.limit);
+    }
+    async function start(key, opts) {
+        const handle = handles[key];
+        if (!handle)
+            throw new Error(`store manager: unknown resource ${key}`);
+        return handle.start(opts);
+    }
+    async function startMany(keys, opts) {
+        const out = {};
+        for (const key of keys)
+            out[key] = await start(key, opts);
+        return out;
+    }
+    async function startPlanned(opts = {}) {
+        const out = {};
+        for (const item of plan(opts))
+            out[item.key] = await handles[item.key].start(opts);
+        return out;
+    }
+    function stop(key) {
+        const handle = handles[key];
+        if (!handle)
+            throw new Error(`store manager: unknown resource ${key}`);
+        handle.stop();
+    }
+    function stopAll() {
+        for (const handle of Object.values(handles))
+            handle.stop();
+    }
+    function get(key) {
+        return handles[key]?.get();
+    }
+    function touch(key, weight) {
+        const handle = handles[key];
+        if (!handle)
+            throw new Error(`store manager: unknown resource ${key}`);
+        handle.touch(weight);
+    }
+    return {
+        handles: handles,
+        statusListen,
+        plan,
+        start,
+        startMany,
+        startPlanned,
+        stop,
+        stopAll,
+        get,
+        touch,
+        usage: () => new Map(usages),
+    };
+}

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/Listen").ListenOnCurrent<[OfflineStoreStatus]>;
+        once: (cb: import("../events/Listen").Listener<[OfflineStoreStatus]>, opts?: {
+            key?: import("../events/Listen").ListenKey;
+            current?: import("../events/Listen").ListenCurrent<[OfflineStoreStatus]> | undefined;
+        }) => import("../events/Listen").ListenOff;
+        emit: import("../events/Listen").Listener<[OfflineStoreStatus]>;
+        has(key: import("../events/Listen").ListenKey): boolean;
+        off(keyOrCallback: import("../events/Listen").ListenKey | import("../events/Listen").Listener<[OfflineStoreStatus]> | null): void;
+        close(): void;
+        count(): number;
+        keys(): import("../events/Listen").ListenKey[];
+        isRunning(): boolean;
+        run(): void;
+        onClose(cb: () => void): import("../events/Listen").ListenOff;
+    };
+    setSyncStatus: (patch: Partial<OfflineStoreStatus>) => void;
+};
+export declare function createOfflineStore<T extends object>(opts: CreateOfflineStoreOpts<T>): Promise<OfflineStore<T>>;