@laboverwire/stitch 0.4.1 → 0.5.0

package/dist/store.js

@@ -1,779 +1,245 @@
-import { OwnershipError } from "./types.js";
-import { createMemoryStore } from "./memory-store.js";
-import { createPersistenceLayer } from "./persistence-layer.js";
-import { createRemoteSyncLayer } from "./remote-sync-layer.js";
-import { createPersistentOfflineQueue, createInMemoryOfflineQueue } from "./offline-queue.js";
-import { stripNulls, isTransientSyncError } from "./internal-utils.js";
-class StoreImpl {
-    config;
-    memory;
-    _persistence = null;
-    _remote = null;
-    _queue = null;
-    options;
-    _ready = false;
-    _initPromise = null;
-    _connectionStatus = 'offline';
-    statusListeners = new Set();
-    currentScopeId = null;
-    initialSyncDone = false;
-    _authenticatedUser = null;
-    _earlySubscribers = [];
-    constructor(config, options) {
-        this.config = config;
-        this.options = options;
-        this.memory = createMemoryStore(config);
+import { createStore as createWasmStore } from '@laboverwire/stitch-wasm';
+const EMPTY_ARRAY = [];
+const EMPTY_MAP = {};
+function normalizeStatus(raw) {
+    switch (raw) {
+        case 'Connected':
+            return 'connected';
+        case 'Connecting':
+            return 'connecting';
+        case 'Disconnected':
+            return 'disconnected';
+        case 'Error':
+            return 'error';
+        default:
+            return 'offline';
     }
-    get ready() {
-        return this._ready;
-    }
-    get connectionStatus() {
-        if (this._remote)
-            return this._remote.connectionStatus;
-        return this._connectionStatus;
+}
+function cacheKey(scopeId, entity) {
+    return `${scopeId} ${entity}`;
+}
+/**
+ * Wire a subscription now if the store is ready, otherwise defer wiring until
+ * `whenReady` resolves. Returns an unsubscribe that cancels the pending wire or
+ * the live subscription, whichever exists. `poke` fires once the deferred
+ * subscription attaches so `useSyncExternalStore`-style consumers re-read.
+ */
+function deferrableSubscribe(isReady, whenReady, subscribeNow, poke) {
+    if (isReady())
+        return subscribeNow();
+    let live = null;
+    let cancelled = false;
+    void whenReady().then(() => {
+        if (cancelled)
+            return;
+        live = subscribeNow();
+        poke();
+    });
+    return () => {
+        cancelled = true;
+        if (live) {
+            live();
+            live = null;
+        }
+    };
+}
+class MemoryView {
+    #inner;
+    #whenReady;
+    #arrays = new Map();
+    #maps = new Map();
+    constructor(inner, whenReady) {
+        this.#inner = inner;
+        this.#whenReady = whenReady;
     }
-    get isReconnecting() {
-        return this._remote?.isReconnecting ?? false;
+    getSnapshot(entity, scopeId) {
+        if (!this.#inner.ready())
+            return EMPTY_ARRAY;
+        const version = this.#inner.getVersion(scopeId, entity);
+        const key = cacheKey(scopeId, entity);
+        const hit = this.#arrays.get(key);
+        if (hit && hit.version === version)
+            return hit.data;
+        const data = this.#inner.getSnapshot(entity, scopeId);
+        this.#arrays.set(key, { version, data });
+        return data;
     }
-    get hasPersistence() {
-        return this._persistence !== null;
+    getSnapshotAsMap(entity, scopeId) {
+        if (!this.#inner.ready())
+            return EMPTY_MAP;
+        const version = this.#inner.getVersion(scopeId, entity);
+        const key = cacheKey(scopeId, entity);
+        const hit = this.#maps.get(key);
+        if (hit && hit.version === version)
+            return hit.data;
+        const data = this.#inner.getSnapshotAsMap(entity, scopeId);
+        this.#maps.set(key, { version, data });
+        return data;
     }
-    get hasRemote() {
-        return this._remote !== null;
+    subscribeToScope(scopeId, entity, callback) {
+        return deferrableSubscribe(() => this.#inner.ready(), this.#whenReady, () => this.#inner.subscribeToScope(scopeId, entity, callback), callback);
     }
-    async initialize() {
-        if (this._ready)
-            return;
-        if (this._initPromise)
-            return this._initPromise;
-        this._initPromise = this.doInitialize().finally(() => {
-            this._initPromise = null;
+}
+class StitchStore {
+    config;
+    memory;
+    #inner;
+    #memory;
+    #hasPersistence;
+    #hasRemote;
+    #reconnectValidator = null;
+    #readyPromise;
+    #resolveReady;
+    constructor(inner, config, options) {
+        this.#inner = inner;
+        this.config = config;
+        this.#hasPersistence = options.persistence != null;
+        this.#hasRemote = options.remote != null;
+        this.#readyPromise = new Promise((resolve) => {
+            this.#resolveReady = resolve;
         });
-        return this._initPromise;
+        this.#memory = new MemoryView(inner, () => this.#readyPromise);
+        this.memory = this.#memory;
     }
-    async doInitialize() {
-        if (this._ready)
-            return;
-        await this.memory.ensureReady();
-        if (this.options.persistence) {
-            const persistence = createPersistenceLayer(this.config);
-            this._persistence = persistence;
-            await persistence.open(this.options.persistence.dbName);
-            this.memory.onCorruption(() => {
-                persistence.notifyCorruption();
-            });
-            for (const entry of this._earlySubscribers) {
-                entry.persistenceUnsub = persistence.subscribe(entry.entity, entry.callback);
-            }
-            this._earlySubscribers = [];
-        }
-        if (this.options.remote) {
-            const remote = createRemoteSyncLayer(this.config);
-            this._remote = remote;
-            if (this._authenticatedUser) {
-                remote.setAuthenticatedUser(this._authenticatedUser);
-            }
-            if (this._persistence) {
-                const queue = createPersistentOfflineQueue(this._persistence, this.config.scope.rootEntity);
-                this._queue = queue;
-                if (this._authenticatedUser && 'setAuthenticatedUser' in queue) {
-                    queue.setAuthenticatedUser(this._authenticatedUser);
-                }
-            }
-            else {
-                this._queue = createInMemoryOfflineQueue(this.config.scope.rootEntity);
-            }
-            remote.setMutationCallback((mutation) => {
-                this.handleRemoteMutation(mutation);
-            });
-            remote.setConnectionChangeCallback((status) => {
-                this._connectionStatus = status;
-                for (const listener of this.statusListeners) {
-                    listener(status);
-                }
-            });
-            remote.setOnConnectedCallback(() => {
-                this.onConnected();
-            });
-            await remote.connect(this.options.remote.serverUrl, this.options.remote.getTicket);
-        }
-        else {
-            this._connectionStatus = 'offline';
-            this.initialSyncDone = true;
-        }
-        if (this._persistence) {
-            this.setupPersistenceSubscriptions();
-        }
-        this._ready = true;
-        if (this._persistence) {
-            this._persistence.notifyAllEntitySubscribers();
-        }
+    #afterReady(fn) {
+        return this.#inner.ready() ? fn() : this.#readyPromise.then(fn);
+    }
+    async initialize() {
+        await this.#inner.initialize();
+        this.#resolveReady();
     }
     destroy() {
-        this._persistence?.close();
-        this._remote?.disconnect();
-        this._ready = false;
-        this._initPromise = null;
+        return this.#inner.ready() ? this.#inner.destroy() : Promise.resolve();
+    }
+    get ready() {
+        return this.#inner.ready();
     }
     read(entity, id) {
-        return this.memory.read(entity, id);
+        if (!this.#inner.ready())
+            return null;
+        return (this.#inner.read(entity, id) ?? null);
     }
     getSnapshot(entity, scopeId) {
-        return this.memory.getSnapshot(entity, scopeId);
+        return this.#memory.getSnapshot(entity, scopeId);
     }
     getSnapshotAsMap(entity, scopeId) {
-        return this.memory.getSnapshotAsMap(entity, scopeId);
-    }
-    async list(entity, filter) {
-        if (this._persistence) {
-            const { scopeField } = this.config.scope;
-            const options = {};
-            if (filter?.scopeId) {
-                options.filters = [{ field: scopeField, op: 'eq', value: filter.scopeId }];
-            }
-            if (filter?.sort && filter.sort.length > 0) {
-                options.sort = filter.sort;
-            }
-            if (filter?.projection && filter.projection.length > 0) {
-                options.projection = filter.projection;
-            }
-            return this._persistence.list(entity, options);
-        }
-        const scopeId = filter?.scopeId ?? '';
-        return Promise.resolve(this.memory.list(entity, scopeId));
-    }
-    async listRootEntities(sort) {
-        if (!this.initialSyncDone && this._remote)
-            return [];
-        if (this._persistence) {
-            const { rootEntity } = this.config.scope;
-            const options = {};
-            if (sort && sort.length > 0) {
-                options.sort = sort;
-            }
-            return this._persistence.list(rootEntity, options);
-        }
-        return Promise.resolve(this.memory.list(this.config.scope.rootEntity, ''));
-    }
-    async getChildCount(entity, scopeId) {
-        if (this._persistence) {
-            const { scopeField } = this.config.scope;
-            return this._persistence.count(entity, {
-                filters: [{ field: scopeField, op: 'eq', value: scopeId }],
-            });
-        }
-        return this.memory.list(entity, scopeId).length;
-    }
-    async create(entity, scopeId, data, tag) {
-        const { rootEntity } = this.config.scope;
-        const id = data.id || crypto.randomUUID();
-        const record = stripNulls({ ...data, id });
-        const effectiveScopeId = entity === rootEntity ? id : scopeId;
-        this.memory.create(entity, effectiveScopeId, record, tag);
-        if (this._persistence) {
-            try {
-                await this._persistence.create(entity, record);
-            }
-            catch (err) {
-                console.error(`[Stitch] Persistence create ${entity} failed:`, err);
-            }
-        }
-        if (this._queue && effectiveScopeId) {
-            await this._queue.queue({
-                op: 'insert',
-                entity,
-                id,
-                scopeId: effectiveScopeId,
-                data: record,
-            });
-        }
-        if (this._remote && this._remote.connectionStatus === 'connected' && effectiveScopeId) {
-            try {
-                await this._remote.syncCreate(entity, effectiveScopeId, record);
-                await this._queue?.remove(entity, id, effectiveScopeId, 'insert');
-            }
-            catch (err) {
-                if (err instanceof OwnershipError) {
-                    await this._queue?.remove(entity, id, effectiveScopeId, 'insert');
-                    console.warn(`[Stitch] OwnershipError on create ${entity}/${id}:`, err.message);
-                    return id;
-                }
-                if (!isTransientSyncError(err)) {
-                    console.error(`[Stitch] Failed to sync create ${entity}:`, err);
-                }
-            }
-        }
-        return id;
-    }
-    async update(entity, id, fields, tag) {
-        const { rootEntity, scopeField } = this.config.scope;
-        const memExisting = this.memory.read(entity, id);
-        let scopeId;
-        if (memExisting) {
-            scopeId = entity === rootEntity ? id : memExisting[scopeField];
-            if (scopeId) {
-                this.memory.update(entity, id, fields, tag);
-            }
-        }
-        if (this._persistence) {
-            if (!scopeId) {
-                let existing;
-                try {
-                    existing = await this._persistence.read(entity, id);
-                }
-                catch (readErr) {
-                    const msg = readErr instanceof Error ? readErr.message : String(readErr);
-                    if (/not found/i.test(msg))
-                        return;
-                    throw readErr;
-                }
-                scopeId = entity === rootEntity ? id : existing[scopeField];
-                if (scopeId && !memExisting) {
-                    this.memory.update(entity, id, fields, tag);
-                }
-            }
-            try {
-                await this._persistence.update(entity, id, fields);
-            }
-            catch (updErr) {
-                console.error(`[Stitch] Persistence update ${entity} failed:`, updErr);
-            }
-        }
-        else if (!memExisting) {
-            return;
-        }
-        if (this._queue && scopeId) {
-            await this._queue.queue({ op: 'update', entity, id, scopeId, data: fields });
-        }
-        if (this._remote && this._remote.connectionStatus === 'connected' && scopeId) {
-            try {
-                await this._remote.syncUpdate(entity, scopeId, id, fields);
-                await this._queue?.remove(entity, id, scopeId, 'update');
-            }
-            catch (err) {
-                if (err instanceof OwnershipError) {
-                    await this._queue?.remove(entity, id, scopeId, 'update');
-                    console.warn(`[Stitch] OwnershipError on update ${entity}/${id}:`, err.message);
-                    return;
-                }
-                const isNotFound = err instanceof Error && /not found/i.test(err.message);
-                if (isNotFound && entity === rootEntity) {
-                    try {
-                        if (this._persistence) {
-                            await this._persistence.delete(rootEntity, id);
-                        }
-                        this.memory.delete(rootEntity, id);
-                    }
-                    catch (cleanupErr) {
-                        console.error(`[Stitch] Cleanup delete ${rootEntity}/${id} failed:`, cleanupErr);
-                    }
-                    await this._queue?.remove(entity, id, scopeId, 'update');
-                }
-                else if (isNotFound) {
-                    try {
-                        let full;
-                        if (this._persistence) {
-                            full = await this._persistence.read(entity, id);
-                        }
-                        else {
-                            full = this.memory.read(entity, id) ?? {};
-                        }
-                        await this._remote.syncCreate(entity, scopeId, full);
-                    }
-                    catch (createErr) {
-                        if (createErr instanceof OwnershipError) {
-                            await this._queue?.remove(entity, id, scopeId, 'update');
-                            console.warn(`[Stitch] OwnershipError on upsert ${entity}/${id}:`, createErr.message);
-                            return;
-                        }
-                        if (!isTransientSyncError(createErr)) {
-                            console.error(`[Stitch] Failed to sync upsert ${entity}:`, createErr);
-                        }
-                    }
-                }
-                else if (!isTransientSyncError(err)) {
-                    console.error(`[Stitch] Failed to sync update ${entity}:`, err);
-                }
-            }
-        }
+        return this.#memory.getSnapshotAsMap(entity, scopeId);
     }
-    async delete(entity, id, tag) {
-        const { rootEntity, scopeField } = this.config.scope;
-        const memExisting = this.memory.read(entity, id);
-        let scopeId;
-        if (memExisting) {
-            scopeId = entity === rootEntity ? id : memExisting[scopeField];
-            if (scopeId) {
-                this.memory.delete(entity, id, tag);
-            }
-        }
-        if (this._persistence) {
-            if (!scopeId) {
-                let existing;
-                try {
-                    existing = await this._persistence.read(entity, id);
-                }
-                catch (readErr) {
-                    const msg = readErr instanceof Error ? readErr.message : String(readErr);
-                    if (/not found/i.test(msg))
-                        return;
-                    throw readErr;
-                }
-                scopeId = entity === rootEntity ? id : existing[scopeField];
-                if (scopeId && !memExisting) {
-                    this.memory.delete(entity, id, tag);
-                }
-            }
-            try {
-                await this._persistence.delete(entity, id);
-            }
-            catch (delErr) {
-                const msg = delErr instanceof Error ? delErr.message : String(delErr);
-                if (/not found/i.test(msg))
-                    return;
-                console.error(`[Stitch] Persistence delete ${entity} failed:`, delErr);
-            }
-        }
-        else if (!memExisting) {
-            return;
-        }
-        if (this._queue && scopeId) {
-            await this._queue.queue({ op: 'delete', entity, id, scopeId, data: null });
-        }
-        if (this._remote && this._remote.connectionStatus === 'connected' && scopeId) {
-            try {
-                await this._remote.syncDelete(entity, scopeId, id);
-                await this._queue?.remove(entity, id, scopeId, 'delete');
-            }
-            catch (err) {
-                if (err instanceof OwnershipError) {
-                    await this._queue?.remove(entity, id, scopeId, 'delete');
-                    console.warn(`[Stitch] OwnershipError on delete ${entity}/${id}:`, err.message);
-                    return;
-                }
-                const isNotFound = err instanceof Error && /not found/i.test(err.message);
-                if (!isNotFound && !isTransientSyncError(err)) {
-                    console.error(`[Stitch] Failed to sync delete ${entity}:`, err);
-                }
-            }
-        }
+    list(entity, filter) {
+        return this.#afterReady(() => this.#inner.list(entity, filter ?? {}));
+    }
+    listRootEntities(sort) {
+        return this.#afterReady(() => this.#inner.listRootEntities(sort ?? []));
+    }
+    getChildCount(entity, scopeId) {
+        if (!this.#inner.ready())
+            return 0;
+        return this.#inner.getChildCount(entity, scopeId);
+    }
+    getVersion(scopeId, entity) {
+        if (!this.#inner.ready())
+            return 0;
+        return this.#inner.getVersion(scopeId, entity);
+    }
+    create(entity, scopeId, data, tag) {
+        return this.#afterReady(() => this.#inner.create(entity, scopeId, data, tag ?? undefined));
+    }
+    update(entity, id, fields, tag) {
+        return this.#afterReady(() => this.#inner.update(entity, id, fields, tag ?? undefined));
+    }
+    delete(entity, id, tag) {
+        return this.#afterReady(() => this.#inner.delete(entity, id, tag ?? undefined));
     }
     subscribeToScope(scopeId, entity, callback) {
-        return this.memory.subscribeToScope(scopeId, entity, callback);
+        return deferrableSubscribe(() => this.#inner.ready(), () => this.#readyPromise, () => this.#inner.subscribeToScope(scopeId, entity, callback), callback);
     }
     subscribeToEntity(entity, callback) {
-        const memUnsub = this.memory.onMutation((event) => {
-            if (event.entity !== entity)
-                return;
-            if (this._persistence && event.originTag !== 'load' && event.originTag !== 'clear')
-                return;
-            const op = event.operation === 'create' ? 'insert' : event.operation;
-            callback(event.data, op);
-        });
-        const entry = {
-            entity,
-            callback: (data, op) => {
-                callback((data ?? null), op);
-            },
-            memoryUnsub: memUnsub,
-            persistenceUnsub: null,
-        };
-        if (this._persistence) {
-            entry.persistenceUnsub = this._persistence.subscribe(entity, entry.callback);
-        }
-        else {
-            this._earlySubscribers.push(entry);
-        }
-        return () => {
-            entry.memoryUnsub();
-            entry.persistenceUnsub?.();
-            const idx = this._earlySubscribers.indexOf(entry);
-            if (idx >= 0)
-                this._earlySubscribers.splice(idx, 1);
-        };
+        return deferrableSubscribe(() => this.#inner.ready(), () => this.#readyPromise, () => this.#inner.subscribeToEntity(entity, (data, op) => callback((data ?? null), op)), () => callback(null, 'update'));
     }
     beginBatch() {
-        this.memory.beginBatch();
+        if (this.#inner.ready())
+            this.#inner.beginBatch();
     }
     endBatch() {
-        this.memory.endBatch();
+        if (this.#inner.ready())
+            this.#inner.endBatch();
     }
-    async replaceScope(scopeId) {
-        if (this.currentScopeId === scopeId)
-            return;
-        const { rootEntity, childEntities } = this.config.scope;
-        if (this.currentScopeId && this.currentScopeId !== scopeId) {
-            const prevScope = this.currentScopeId;
-            this.currentScopeId = scopeId;
-            this.closeScope(prevScope).catch(() => { });
-        }
-        else {
-            this.currentScopeId = scopeId;
-        }
-        if (this._remote && this._remote.connectionStatus === 'connected') {
-            if (this._persistence) {
-                this._persistence.setSuppressNotifications(true);
-            }
-            try {
-                const state = await this._remote.openScope(scopeId);
-                if (this._persistence) {
-                    const localAccessor = this.createLocalAccessor();
-                    const versionField = this.config.versionField ?? 'version';
-                    if (state.root && state.root.id) {
-                        if (state.root[versionField] != null && typeof state.root[versionField] !== 'number') {
-                            state.root[versionField] = Number(state.root[versionField]) || 1;
-                        }
-                        try {
-                            await localAccessor.read(rootEntity, state.root.id);
-                            await localAccessor.update(rootEntity, state.root.id, state.root);
-                        }
-                        catch {
-                            await localAccessor.create(rootEntity, state.root);
-                        }
-                    }
-                    else {
-                        try {
-                            await localAccessor.read(rootEntity, scopeId);
-                        }
-                        catch {
-                            return;
-                        }
-                    }
-                    for (const childEntity of childEntities) {
-                        const serverChildren = state.children[childEntity] ?? [];
-                        await this._remote.reconcileChildren(scopeId, childEntity, serverChildren, localAccessor, this._queue);
-                    }
-                    for (const mutation of state.bufferedMutations) {
-                        await this._remote.applyMutationToDb(mutation, localAccessor);
-                    }
-                    const bundle = await this.loadScopeFromPersistence(scopeId);
-                    if (bundle) {
-                        this.memory.loadScope(scopeId, bundle, 'load');
-                    }
-                    await this.loadRootIntoMemory(rootEntity, scopeId);
-                }
-                else {
-                    this.memory.loadScope(scopeId, state.children, 'load');
-                    if (state.root && state.root.id) {
-                        this.memory.create(rootEntity, scopeId, state.root, 'load');
-                    }
-                }
-            }
-            catch (err) {
-                console.error('[Stitch] Failed to open scope from server:', err);
-                if (this._persistence) {
-                    const bundle = await this.loadScopeFromPersistence(scopeId);
-                    if (bundle) {
-                        this.memory.loadScope(scopeId, bundle, 'load');
-                    }
-                    await this.loadRootIntoMemory(rootEntity, scopeId);
-                }
-            }
-            finally {
-                if (this._persistence) {
-                    this._persistence.setSuppressNotifications(false);
-                }
-            }
-        }
-        else if (this._persistence) {
-            const bundle = await this.loadScopeFromPersistence(scopeId);
-            if (bundle) {
-                this.memory.loadScope(scopeId, bundle, 'load');
-            }
-            await this.loadRootIntoMemory(rootEntity, scopeId);
-        }
+    replaceScope(scopeId) {
+        return this.#afterReady(() => this.#inner.replaceScope(scopeId));
     }
-    async closeScope(scopeId) {
-        if (this._remote) {
-            await this._remote.closeScope(scopeId);
-        }
-        if (this.currentScopeId === scopeId) {
-            this.currentScopeId = null;
-        }
+    closeScope(scopeId) {
+        return this.#afterReady(() => this.#inner.closeScope(scopeId));
     }
     loadScope(scopeId, data) {
-        this.memory.loadScope(scopeId, data);
+        return this.#afterReady(() => this.#inner.loadScope(scopeId, data));
     }
     clearScope(scopeId) {
-        this.memory.clearScope(scopeId);
+        return this.#afterReady(() => this.#inner.clearScope(scopeId));
+    }
+    get connectionStatus() {
+        if (!this.#inner.ready())
+            return 'offline';
+        return normalizeStatus(this.#inner.connectionStatus());
     }
     subscribeToConnectionStatus(cb) {
-        if (this._remote) {
-            return this._remote.subscribeToConnectionStatus(cb);
-        }
-        this.statusListeners.add(cb);
-        cb(this._connectionStatus);
-        return () => this.statusListeners.delete(cb);
+        return deferrableSubscribe(() => this.#inner.ready(), () => this.#readyPromise, () => this.#inner.subscribeToConnectionStatus((raw) => cb(normalizeStatus(raw))), () => cb(normalizeStatus(this.#inner.connectionStatus())));
     }
     disconnect() {
-        this._remote?.disconnect();
-        this._connectionStatus = 'offline';
+        return this.#inner.ready() ? this.#inner.disconnect() : Promise.resolve();
     }
     async reconnect(serverUrl, getTicket) {
-        if (this._remote) {
-            await this._remote.reconnect(serverUrl, getTicket);
-        }
+        if (this.#reconnectValidator)
+            await this.#reconnectValidator();
+        const ticket = getTicket ? await getTicket() : undefined;
+        await this.#inner.reconnect(serverUrl, ticket ?? undefined);
+    }
+    get isReconnecting() {
+        if (!this.#inner.ready())
+            return false;
+        return this.#inner.isReconnecting();
     }
     setAuthenticatedUser(userId) {
-        this._authenticatedUser = userId;
-        this._remote?.setAuthenticatedUser(userId);
-        if (this._queue && 'setAuthenticatedUser' in this._queue) {
-            this._queue.setAuthenticatedUser(userId);
-        }
+        if (this.#inner.ready())
+            this.#inner.setAuthenticatedUser(userId);
+        else
+            void this.#readyPromise.then(() => this.#inner.setAuthenticatedUser(userId));
     }
     setSessionInvalidHandler(handler) {
-        this._remote?.setSessionInvalidHandler(handler);
+        if (this.#inner.ready())
+            this.#inner.setSessionInvalidHandler(handler);
+        else
+            void this.#readyPromise.then(() => this.#inner.setSessionInvalidHandler(handler));
     }
     setReconnectValidator(validator) {
-        this._remote?.setReconnectValidator(validator);
+        this.#reconnectValidator = validator;
     }
     resetForLogout() {
-        this._remote?.resetForLogout();
-        this._persistence?.close();
-        this._persistence = null;
-        this._queue = null;
-        this._ready = false;
-        this._initPromise = null;
-        this._earlySubscribers = [];
-        this.currentScopeId = null;
-        this._authenticatedUser = null;
-        this.initialSyncDone = false;
-        this._connectionStatus = 'offline';
-        sessionStorage.removeItem('stitch_cached_user');
-        sessionStorage.removeItem('stitch_pending_logout');
-    }
-    async request(topic, payload) {
-        if (!this._remote)
-            throw new Error('No remote connection');
-        return this._remote.request(topic, payload);
-    }
-    async readLocalState(entity, id) {
-        if (this._persistence) {
-            return this._persistence.readLocalState(entity, id);
-        }
-        return this.memory.read(entity, id);
-    }
-    async updateLocalState(entity, id, fields) {
-        if (this._persistence) {
-            await this._persistence.updateLocalState(entity, id, fields);
-        }
-        else {
-            const existing = this.memory.read(entity, id);
-            if (existing) {
-                this.memory.update(entity, id, fields);
-            }
-        }
+        return this.#inner.ready() ? this.#inner.resetForLogout() : Promise.resolve();
     }
-    async getCachedUser() {
-        try {
-            const raw = sessionStorage.getItem('stitch_cached_user');
-            if (!raw)
-                return null;
-            const envelope = JSON.parse(raw);
-            if (typeof envelope !== 'object' || envelope === null)
-                return null;
-            const { user, cachedAt } = envelope;
-            const MAX_AGE_MS = 15 * 60 * 1000;
-            if (typeof cachedAt !== 'number' || Date.now() - cachedAt > MAX_AGE_MS) {
-                sessionStorage.removeItem('stitch_cached_user');
-                return null;
-            }
-            if (typeof user !== 'object' || user === null)
-                return null;
-            return user;
-        }
-        catch {
-            return null;
-        }
-    }
-    async setCachedUser(user) {
-        sessionStorage.setItem('stitch_cached_user', JSON.stringify({ user, cachedAt: Date.now() }));
-        sessionStorage.removeItem('stitch_pending_logout');
+    readLocalState(entity, id) {
+        return this.#afterReady(() => this.#inner
+            .readLocalState(entity, id)
+            .then((r) => (r ?? null)));
     }
-    async clearCachedUser() {
-        sessionStorage.removeItem('stitch_cached_user');
-    }
-    async hasPendingLogout() {
-        return sessionStorage.getItem('stitch_pending_logout') === 'true';
-    }
-    async setPendingLogout(pending) {
-        if (pending) {
-            sessionStorage.setItem('stitch_pending_logout', 'true');
-        }
-        else {
-            sessionStorage.removeItem('stitch_pending_logout');
-        }
-    }
-    async flushPendingLogout(logoutFn) {
-        const pending = await this.hasPendingLogout();
-        if (!pending)
-            return;
-        try {
-            await logoutFn();
-            await this.setPendingLogout(false);
-        }
-        catch { }
-    }
-    async handleRemoteMutation(mutation) {
-        const localAccessor = this.createLocalAccessor();
-        if (this._remote) {
-            await this._remote.applyMutationToDb(mutation, localAccessor);
-        }
-        if (!this._persistence) {
-            const { scopeField } = this.config.scope;
-            switch (mutation.op) {
-                case 'insert':
-                    if (mutation.data) {
-                        const sid = mutation.data[scopeField];
-                        if (sid) {
-                            this.memory.create(mutation.entity, sid, { ...mutation.data, id: mutation.id }, 'remote');
-                        }
-                    }
-                    break;
-                case 'update':
-                    if (mutation.data) {
-                        this.memory.update(mutation.entity, mutation.id, mutation.data, 'remote');
-                    }
-                    break;
-                case 'delete':
-                    this.memory.delete(mutation.entity, mutation.id, 'remote');
-                    break;
-            }
-        }
+    updateLocalState(entity, id, fields) {
+        return this.#afterReady(() => this.#inner.updateLocalState(entity, id, fields));
     }
-    async onConnected() {
-        try {
-            if (this._queue && this._remote) {
-                const sender = this.createMutationSender();
-                await this._queue.flush(sender);
-                await this._queue.flush(sender);
-            }
-            if (this._remote) {
-                const localAccessor = this.createLocalAccessor();
-                this.initialSyncDone = false;
-                await this._remote.syncRootEntityList(localAccessor, this._queue);
-                this.initialSyncDone = true;
-            }
-            this._persistence?.notifyAllEntitySubscribers();
-        }
-        catch (err) {
-            void err;
-            this.initialSyncDone = true;
-        }
+    pendingMutationCount(scopeId) {
+        return this.#afterReady(() => this.#inner.pendingMutationCount(scopeId));
     }
-    createLocalAccessor() {
-        if (this._persistence) {
-            return {
-                read: (entity, id) => this._persistence.read(entity, id),
-                list: (entity, options) => this._persistence.list(entity, options),
-                create: (entity, data) => this._persistence.create(entity, data),
-                update: (entity, id, data) => this._persistence.update(entity, id, data),
-                delete: (entity, id) => this._persistence.delete(entity, id),
-            };
-        }
-        return {
-            read: async (entity, id) => {
-                const result = this.memory.read(entity, id);
-                if (!result)
-                    throw new Error(`${entity} ${id} not found`);
-                return result;
-            },
-            list: async (entity, options) => {
-                const filters = options.filters;
-                if (filters && filters.length > 0) {
-                    const scopeFilter = filters.find((f) => f.field === this.config.scope.scopeField);
-                    if (scopeFilter) {
-                        return this.memory.list(entity, scopeFilter.value);
-                    }
-                }
-                return this.memory.list(entity, '');
-            },
-            create: async (entity, data) => {
-                const { scopeField } = this.config.scope;
-                const scopeId = data[scopeField];
-                this.memory.create(entity, scopeId ?? '', data, 'remote');
-            },
-            update: async (entity, id, data) => {
-                this.memory.update(entity, id, data, 'remote');
-            },
-            delete: async (entity, id) => {
-                this.memory.delete(entity, id, 'remote');
-            },
-        };
-    }
-    createMutationSender() {
-        return {
-            syncCreate: (entity, scopeId, data) => this._remote.syncCreate(entity, scopeId, data),
-            syncUpdate: (entity, scopeId, id, data) => this._remote.syncUpdate(entity, scopeId, id, data),
-            syncDelete: (entity, scopeId, id) => this._remote.syncDelete(entity, scopeId, id),
-            readEntity: async (entity, id) => {
-                if (this._persistence) {
-                    return this._persistence.read(entity, id);
-                }
-                const result = this.memory.read(entity, id);
-                if (!result)
-                    throw new Error(`${entity} ${id} not found`);
-                return result;
-            },
-            deleteEntity: async (entity, id) => {
-                if (this._persistence) {
-                    await this._persistence.delete(entity, id);
-                }
-                this.memory.delete(entity, id);
-            },
-        };
-    }
-    async loadRootIntoMemory(rootEntity, scopeId) {
-        if (!this._persistence)
-            return;
-        try {
-            const rootRecord = await this._persistence.read(rootEntity, scopeId);
-            this.memory.create(rootEntity, scopeId, rootRecord, 'load');
-        }
-        catch (readErr) {
-            console.debug(`[Stitch] Root entity ${rootEntity}/${scopeId} not in persistence:`, readErr);
-        }
+    request(topic, payload) {
+        return this.#afterReady(() => this.#inner.request(topic, payload));
     }
-    async loadScopeFromPersistence(scopeId) {
-        if (!this._persistence)
-            return null;
-        const { childEntities, scopeField } = this.config.scope;
-        const children = {};
-        for (const entity of childEntities) {
-            children[entity] = await this._persistence.list(entity, {
-                filters: [{ field: scopeField, op: 'eq', value: scopeId }],
-            });
-        }
-        return children;
+    get hasPersistence() {
+        return this.#hasPersistence;
     }
-    setupPersistenceSubscriptions() {
-        if (!this._persistence)
-            return;
-        const { childEntities, scopeField } = this.config.scope;
-        for (const entity of childEntities) {
-            this._persistence.subscribe(entity, (entityData, op) => {
-                if (entityData === null || typeof entityData !== 'object')
-                    return;
-                const record = entityData;
-                const sid = record[scopeField];
-                if (!sid || sid !== this.currentScopeId)
-                    return;
-                switch (op) {
-                    case 'insert':
-                        this.memory.create(entity, sid, record, 'remote');
-                        break;
-                    case 'update':
-                        this.memory.update(entity, record.id, record, 'remote');
-                        break;
-                    case 'delete':
-                        this.memory.delete(entity, record.id, 'remote');
-                        break;
-                }
-            });
-        }
+    get hasRemote() {
+        return this.#hasRemote;
     }
 }
 export function createStore(config, options) {
-    return new StoreImpl(config, options ?? {});
+    const resolvedOptions = options ?? {};
+    const inner = createWasmStore(config, resolvedOptions);
+    return new StitchStore(inner, config, resolvedOptions);
 }
 //# sourceMappingURL=store.js.map