zerodrift 1.0.0

package/dist/core/BaseModel.js

@@ -0,0 +1,505 @@
+/**
+ * BaseModel — the base class for all sync engine models.
+ *
+ * Lifecycle:
+ *   1. `new Issue()`            — raw construction, observability OFF
+ *   2. `issue.hydrate(data)`    — populate flat values, recursive for embedded objects
+ *   3. `issue.makeModelObservable()` — create MobX boxes + RefCollections
+ *   4. `issue.title = "..."`    — setter fires, tracked in pendingChanges
+ *   5. `issue.save()`           — builds transaction, auto-commits to server
+ *
+ * makeModelObservable() creates the runtime relationship objects:
+ *   - RefCollection for @ReferenceCollection properties
+ *   - BackRef for @BackReference properties
+ * These are stored on __collections and __backRefs, read by the decorator getters.
+ */
+import { ModelRegistry } from "./ModelRegistry";
+import { PropertyType, DEFAULT_TRANSIENT_INDEX_DEPTH, } from "./types";
+import { RefCollection, BackRef } from "./LazyCollection";
+import { OwnedRefs } from "./LazyOwnedCollection";
+import { action, computed, observable, reaction, runInAction, } from "mobx";
+// The four PropertyTypes that have MobX boxes and direct setters — the "flat scalar" fields.
+// Used by makeModelObservable (to create boxes) and assign() (to filter writable keys).
+const FLAT_PROPERTY_TYPES = new Set([
+    PropertyType.Property,
+    PropertyType.EphemeralProperty,
+    PropertyType.Reference,
+    PropertyType.ReferenceArray,
+]);
+export class BaseModel {
+    constructor() {
+        this.id = BaseModel.storeManager?.mintId(this) ?? crypto.randomUUID();
+        this.__mobx = {};
+        this.__observabilityEnabled = false;
+        this.store = null;
+        /** Runtime lazy collections, keyed by property name. */
+        this.__collections = {};
+        /** Runtime BackRefs, keyed by property name. Read by @BackReference getters. */
+        this.__backRefs = {};
+        this.pendingChanges = new Map();
+    }
+    // Backed by globalThis so it survives HMR module reloads in dev mode.
+    // Bundlers (webpack, Vite, etc.) re-execute modules on hot reload, which
+    // resets static field initializers — but globalThis is outside the module
+    // system and is never reset, keeping the live StoreManager reachable for
+    // new model instances created after a reload.
+    static get storeManager() {
+        return (globalThis
+            .__syncEngineStore ?? null);
+    }
+    static set storeManager(sm) {
+        globalThis.__syncEngineStore = sm ?? null;
+    }
+    // ---------------------------------------------------------------------------
+    // Change tracking
+    // ---------------------------------------------------------------------------
+    /**
+     * Set a property value without triggering change tracking or pendingChanges.
+     * Used by revert paths so that rolling back an optimistic update doesn't
+     * leave the model in a dirty state.
+     */
+    setQuiet(propName, value) {
+        const box = this.__mobx[propName];
+        if (box != null) {
+            box.set(value);
+        }
+        this[`__raw_${propName}`] = value;
+        this.pendingChanges.delete(propName);
+    }
+    propertyChanged(propName, oldValue, newValue) {
+        if (oldValue === newValue) {
+            return;
+        }
+        const sm = BaseModel.storeManager;
+        sm?.registerAtomicTouch(this);
+        if (!this.pendingChanges.has(propName)) {
+            const wasClean = this.pendingChanges.size === 0;
+            const meta = ModelRegistry.getMetaForInstance(this);
+            const propMeta = meta?.properties.get(propName);
+            const serialized = propMeta?.serializer != null ? propMeta.serializer(oldValue) : oldValue;
+            this.pendingChanges.set(propName, serialized);
+            // Invalidate any OwnedCollections backed by this property so they
+            // re-resolve against the updated IDs array on next access.
+            if (meta != null) {
+                for (const [collectionName, ownedPropMeta] of meta.properties) {
+                    if (ownedPropMeta.type === PropertyType.OwnedCollection &&
+                        ownedPropMeta.idsField === propName) {
+                        this.__collections[collectionName]?.invalidate();
+                    }
+                }
+                this.maintainParentLinks(meta.name, propName, oldValue, newValue);
+            }
+            // Clean→dirty transition: fire after parent links are consistent so an
+            // adopter materializing a draft scaffold sees correct inverse links.
+            if (wasClean && sm != null && sm.hasModelTouchedHandler && meta != null) {
+                sm.fireModelTouched(this, meta.name);
+            }
+        }
+    }
+    /** Forward an FK change to the pool so it can re-route inverse links. No-op
+     * before the model has entered a pool. */
+    maintainParentLinks(modelName, propName, oldValue, newValue) {
+        const pool = this.store;
+        if (pool == null) {
+            return;
+        }
+        const oldId = typeof oldValue === "string" ? oldValue : null;
+        const newId = typeof newValue === "string" ? newValue : null;
+        pool.notifyReferenceChange(this, modelName, propName, oldId, newId);
+    }
+    // ---------------------------------------------------------------------------
+    // makeModelObservable — create MobX boxes + relationship runtime objects
+    // ---------------------------------------------------------------------------
+    makeModelObservable() {
+        // Idempotent: re-running would replace the RefCollection /
+        // BackRef / OwnedRefs runtime objects, dropping
+        // their loaded items, and re-fire any non-lazy eager loads.
+        if (this.__observabilityEnabled) {
+            return;
+        }
+        this.__observabilityEnabled = true;
+        const meta = ModelRegistry.getMetaForInstance(this);
+        if (meta == null) {
+            return;
+        }
+        for (const [name, prop] of meta.properties) {
+            switch (prop.type) {
+                // ── Flat observable properties: create MobX boxes ──
+                case PropertyType.Property:
+                case PropertyType.EphemeralProperty:
+                case PropertyType.Reference:
+                case PropertyType.ReferenceArray: {
+                    const rawValue = this[`__raw_${name}`];
+                    let currentValue = rawValue;
+                    // SWC (Next.js) compiles class fields using "define" semantics
+                    // (Object.defineProperty), creating own data properties that shadow
+                    // the prototype getter/setter installed by @Property. Delete them so
+                    // the prototype accessor is reachable for all future reads and writes.
+                    const ownDesc = Object.getOwnPropertyDescriptor(this, name);
+                    if (ownDesc != null && "value" in ownDesc) {
+                        if (currentValue === undefined) {
+                            // hydrate() hasn't run yet (new model) — preserve the class field value.
+                            currentValue = ownDesc.value;
+                        }
+                        delete this[name];
+                    }
+                    if (currentValue !== undefined) {
+                        if (this.__mobx[name] != null) {
+                            this.__mobx[name].set(currentValue);
+                        }
+                        else {
+                            // Create the box directly to avoid triggering propertyChanged.
+                            this.__mobx[name] = observable.box(currentValue, { deep: false });
+                            this[`__raw_${name}`] = currentValue;
+                        }
+                    }
+                    if (prop.type === PropertyType.Reference &&
+                        prop.lazy === false &&
+                        BaseModel.storeManager != null &&
+                        typeof currentValue === "string" &&
+                        currentValue !== "") {
+                        const sm = BaseModel.storeManager;
+                        const refTo = prop.referenceTo;
+                        const id = currentValue;
+                        sm.getOrLoadById(refTo, id).catch((err) => {
+                            sm.emitError(err, {
+                                kind: "eagerReferenceLoad",
+                                modelName: refTo,
+                                id,
+                            });
+                        });
+                    }
+                    break;
+                }
+                // ── ReferenceCollection → create RefCollection ──
+                // e.g. Team.issues → RefCollection("Issue", "teamId")
+                // The collection's hydrate() stores the parent ID and computes
+                // the partial index values for future IDB queries — manual
+                // coveringIndexes plus auto-derived paths from the FK graph walk.
+                case PropertyType.ReferenceCollection: {
+                    const depth = BaseModel.storeManager?.transientIndexDepth ??
+                        DEFAULT_TRANSIENT_INDEX_DEPTH;
+                    const derivedPaths = depth > 0
+                        ? ModelRegistry.getDerivedCoveringPaths(meta.name, prop.referenceTo, depth)
+                        : [];
+                    const collection = new RefCollection(prop.referenceTo, prop.inverseOf, prop.coveringIndexes ?? [], derivedPaths);
+                    collection.hydrate(this);
+                    // Wire loader from StoreManager (for async IDB/server loading)
+                    if (BaseModel.storeManager != null) {
+                        const sm = BaseModel.storeManager;
+                        collection.setLoader(async (modelName, queries) => {
+                            // Each axis is an independent IDB read; fire in parallel.
+                            const batches = await Promise.all(queries.map((q) => sm.getOrLoadCollection(modelName, q.key, q.value)));
+                            return batches.flat();
+                        });
+                        const parentModelName = meta.name;
+                        const parentId = this.id;
+                        const refTo = prop.referenceTo;
+                        const isEager = prop.lazy === false;
+                        collection.setOnError((err) => {
+                            sm.emitError(err, {
+                                kind: isEager ? "eagerCollectionLoad" : "lazyCollectionLoad",
+                                modelName: refTo,
+                                parentModelName,
+                                parentId,
+                            });
+                        });
+                    }
+                    this.__collections[name] = collection;
+                    if (prop.lazy === false && BaseModel.storeManager != null) {
+                        void collection.load();
+                    }
+                    break;
+                }
+                // ── OwnedCollection → create OwnedRefs ──
+                // e.g. Team.issues where Team has issueIds: string[]
+                // The idsGetter is a live function — reads the current array each time,
+                // so additions/removals to issueIds are always reflected.
+                case PropertyType.OwnedCollection: {
+                    const idsField = prop.idsField;
+                    const collection = new OwnedRefs(prop.referenceTo, 
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    () => this[idsField] ?? []);
+                    if (BaseModel.storeManager != null) {
+                        const sm = BaseModel.storeManager;
+                        collection.setLoader(async (modelName, ids) => {
+                            return sm.getOrLoadByIds(modelName, ids);
+                        });
+                        const refTo = prop.referenceTo;
+                        collection.setOnError((err) => {
+                            sm.emitError(err, {
+                                kind: "lazyOwnedCollectionLoad",
+                                modelName: refTo,
+                            });
+                        });
+                    }
+                    this.__collections[name] = collection;
+                    if (prop.lazy === false && BaseModel.storeManager != null) {
+                        void collection.load();
+                    }
+                    break;
+                }
+                // ── BackReference → create BackRef ──
+                // e.g. Issue.favorite → BackRef("Favorite", "issueId")
+                case PropertyType.BackReference: {
+                    const backRef = new BackRef(prop.referenceTo, prop.inverseOf);
+                    backRef.hydrate(this.id);
+                    if (BaseModel.storeManager != null) {
+                        const sm = BaseModel.storeManager;
+                        backRef.setLoader(async (modelName, key, value) => {
+                            const items = await sm.getOrLoadCollection(modelName, key, value);
+                            return items[0] ?? null;
+                        });
+                        const refTo = prop.referenceTo;
+                        const parentId = this.id;
+                        backRef.setOnError((err) => {
+                            sm.emitError(err, {
+                                kind: "lazyBackRefLoad",
+                                modelName: refTo,
+                                parentId,
+                            });
+                        });
+                    }
+                    this.__backRefs[name] = backRef;
+                    break;
+                }
+            }
+        }
+        // ── Wire @Action methods with MobX action() ──
+        // Wraps the method so multiple property changes inside it are batched
+        // into a single MobX transaction (one re-render, not N).
+        for (const actionName of meta.actions) {
+            const original = this[actionName];
+            if (typeof original === "function") {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                this[actionName] = action(original.bind(this));
+            }
+        }
+        // ── Wire @Computed getters with MobX computed() ──
+        // Memoizes the getter — re-evaluates only when its observed dependencies change.
+        for (const compName of meta.computedProps) {
+            const descriptor = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(this), compName);
+            if (descriptor?.get != null) {
+                const fn = descriptor.get.bind(this);
+                const memo = computed(fn);
+                Object.defineProperty(this, compName, {
+                    get: () => memo.get(),
+                    configurable: true,
+                });
+            }
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Save
+    // ---------------------------------------------------------------------------
+    save() {
+        const meta = ModelRegistry.getMetaForInstance(this);
+        if (this.store === null) {
+            BaseModel.storeManager?.commitCreate(this);
+            return {};
+        }
+        // Stamp updatedAt when there are actual changes, if the model declares it as a @Property.
+        if (this.pendingChanges.size > 0 &&
+            meta?.properties.has("updatedAt") === true) {
+            this["updatedAt"] = new Date();
+        }
+        const changes = {};
+        for (const [propName, oldSerialized] of this.pendingChanges) {
+            const propMeta = meta?.properties.get(propName);
+            const currentValue = this[propName];
+            const newSerialized = propMeta?.serializer != null
+                ? propMeta.serializer(currentValue)
+                : currentValue;
+            changes[propName] = { oldValue: oldSerialized, newValue: newSerialized };
+        }
+        this.pendingChanges.clear();
+        if (BaseModel.storeManager != null && Object.keys(changes).length > 0) {
+            BaseModel.storeManager.commitUpdate(this.id, meta?.name ?? "Unknown", changes);
+        }
+        return changes;
+    }
+    get hasUnsavedChanges() {
+        return this.pendingChanges.size > 0;
+    }
+    /**
+     * Revert all unsaved property changes to their last-saved values.
+     * Mirror of save() — where save() commits forward, this rolls back.
+     */
+    discardUnsavedChanges() {
+        if (this.pendingChanges.size === 0) {
+            return;
+        }
+        const meta = ModelRegistry.getMetaForInstance(this);
+        const entries = Array.from(this.pendingChanges);
+        runInAction(() => {
+            for (const [propName, serializedOldValue] of entries) {
+                const propMeta = meta?.properties.get(propName);
+                const deserialized = propMeta?.deserializer != null
+                    ? propMeta.deserializer(serializedOldValue)
+                    : serializedOldValue;
+                this.setQuiet(propName, deserialized);
+            }
+        });
+        this.pendingChanges.clear();
+    }
+    /**
+     * React to property changes on this model without importing MobX.
+     * Use on models obtained from the pool — `objectPool.getById` / `objectPool.getAll`.
+     *
+     * @param selector - reads the property (or derived value) to observe
+     * @param callback - fires whenever the selector result changes; receives new and previous value
+     * @returns unwatch function — call it to stop observing
+     */
+    watch(selector, callback) {
+        return reaction(() => selector(this), callback);
+    }
+    // ---------------------------------------------------------------------------
+    // Field assignment
+    // ---------------------------------------------------------------------------
+    /**
+     * Stage a bulk field assignment without committing. Changes land in
+     * `pendingChanges` and stay local until `save()` (or an enclosing
+     * `StoreManager.atomic()` / `store.batch()`) flushes them, or
+     * `discardUnsavedChanges()` rolls them back. This is the staging
+     * primitive behind `store.<entity>.draft(...)`.
+     *
+     * Only `@Property`, `@EphemeralProperty`, `@Reference` (ID fields), and
+     * `@ReferenceArray` fields are written — relationship objects and internals
+     * are ignored.
+     */
+    assign(data) {
+        const meta = ModelRegistry.getMetaForInstance(this);
+        runInAction(() => {
+            for (const [key, value] of Object.entries(data)) {
+                if (key === "id") {
+                    continue;
+                }
+                const propMeta = meta?.properties.get(key);
+                if (propMeta == null || !FLAT_PROPERTY_TYPES.has(propMeta.type)) {
+                    continue;
+                }
+                this[key] = value;
+            }
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // Hydration — flat values + recursive for embedded objects
+    // ---------------------------------------------------------------------------
+    /** @internal */
+    hydrate(data) {
+        const meta = ModelRegistry.getMetaForInstance(this);
+        // Wrap multi-field updates in a single MobX action so observers see one
+        // coherent transition for SSE deltas that touch many fields at once.
+        runInAction(() => {
+            for (const [key, value] of Object.entries(data)) {
+                if (key === "id") {
+                    this.id = value;
+                    continue;
+                }
+                const propMeta = meta?.properties.get(key);
+                // Recursive hydration: if a ReferenceModel property has an embedded object,
+                // create a model instance from it and put it in the pool.
+                if (propMeta?.type === PropertyType.ReferenceModel &&
+                    value &&
+                    typeof value === "object" &&
+                    "id" in value) {
+                    const nested = value;
+                    this.hydrateNestedModel(propMeta.referenceTo, nested);
+                    const idKey = propMeta.idField ?? key + "Id";
+                    // Rebase: if the FK is being optimistically edited, keep the
+                    // optimistic value visible but update its stored baseline to the
+                    // server's value, so a later `discardUnsavedChanges()` lands on
+                    // the rebased server truth rather than the stale pre-edit value.
+                    if (this.pendingChanges.has(idKey)) {
+                        this.pendingChanges.set(idKey, nested.id);
+                    }
+                    else {
+                        this[`__raw_${idKey}`] = nested.id;
+                    }
+                    continue;
+                }
+                const deserialized = propMeta?.deserializer != null ? propMeta.deserializer(value) : value;
+                // Rebase path mirrors UpdateTransaction.rebase: pendingChanges holds
+                // the serialized baseline; an incoming server value that differs
+                // from our optimistic newValue overwrites it. Echo of our own change
+                // (server === optimistic) is a no-op.
+                if (this.pendingChanges.has(key)) {
+                    const currentValue = this[key];
+                    const optimisticSerialized = propMeta?.serializer != null
+                        ? propMeta.serializer(currentValue)
+                        : currentValue;
+                    const serverSerialized = propMeta?.serializer != null
+                        ? propMeta.serializer(deserialized)
+                        : value;
+                    if (serverSerialized !== optimisticSerialized) {
+                        this.pendingChanges.set(key, serverSerialized);
+                    }
+                    continue;
+                }
+                const oldRawValue = this[`__raw_${key}`];
+                this[`__raw_${key}`] = deserialized;
+                const box = this.__mobx[key];
+                if (box != null) {
+                    box.set(deserialized);
+                }
+                // box.set bypasses the prototype setter, so propertyChanged never fires
+                // for delta-driven hydrates. Dispatch parent-link maintenance directly
+                // so SSE-driven FK changes still wake the inverse RefCollection / BackRef.
+                if (this.store != null && meta != null) {
+                    this.maintainParentLinks(meta.name, key, oldRawValue, deserialized);
+                }
+            }
+        });
+    }
+    hydrateNestedModel(modelName, data) {
+        const pool = this.store ?? BaseModel.storeManager?.objectPool;
+        if (pool == null) {
+            return;
+        }
+        const existing = pool.getById(modelName, data.id);
+        if (existing != null) {
+            existing.hydrate(data);
+            return;
+        }
+        const refMeta = ModelRegistry.getModelMeta(modelName);
+        if (refMeta == null) {
+            return;
+        }
+        const instance = new refMeta.ctor();
+        instance.hydrate(data); // recursive
+        instance.makeModelObservable();
+        pool.put(modelName, instance);
+    }
+    // ---------------------------------------------------------------------------
+    // Serialization
+    // ---------------------------------------------------------------------------
+    serialize() {
+        const meta = ModelRegistry.getMetaForInstance(this);
+        const out = {
+            id: this.id,
+        };
+        if (meta == null) {
+            return out;
+        }
+        for (const [name, prop] of meta.properties) {
+            if (prop.type === PropertyType.EphemeralProperty) {
+                continue;
+            }
+            if (prop.type === PropertyType.ReferenceModel) {
+                continue;
+            }
+            if (prop.type === PropertyType.ReferenceCollection) {
+                continue;
+            }
+            if (prop.type === PropertyType.BackReference) {
+                continue;
+            }
+            if (prop.type === PropertyType.OwnedCollection) {
+                continue;
+            }
+            const value = this[name];
+            out[name] = prop.serializer != null ? prop.serializer(value) : value;
+        }
+        return out;
+    }
+}

package/dist/core/BaseSSEConnection.d.ts

@@ -0,0 +1,31 @@
+import { type EngineErrorContext } from "./types";
+export interface SSEClient {
+    onmessage: ((event: {
+        data: string;
+    }) => void) | null;
+    onerror: ((event?: any) => void) | null;
+    close(): void;
+}
+export type SSEClientFactory = (url: string) => SSEClient;
+export type SSEErrorReporter = (err: Error, context: EngineErrorContext) => void;
+export declare const createBrowserSSEFactory: (init?: EventSourceInit) => SSEClientFactory;
+export declare abstract class BaseSSEConnection {
+    protected url: string;
+    private sseClientFactory;
+    private reportError?;
+    private eventSource;
+    private reconnectTimer;
+    private stopped;
+    constructor(url: string, sseClientFactory?: SSEClientFactory, reportError?: SSEErrorReporter | undefined);
+    connect(): void;
+    disconnect(): void;
+    reconnect(): void;
+    get isConnected(): boolean;
+    protected buildUrl(): string;
+    protected abstract onMessage(data: string): void;
+    protected onReconnect(): void;
+    protected onOpen(): void;
+    protected onClose(): void;
+    private openEventSource;
+    private scheduleReconnect;
+}

package/dist/core/BaseSSEConnection.js

@@ -0,0 +1,91 @@
+import { toError } from "./types";
+export const createBrowserSSEFactory = (init) => (url) => new EventSource(url, init);
+export class BaseSSEConnection {
+    constructor(url, sseClientFactory = createBrowserSSEFactory(), reportError) {
+        this.url = url;
+        this.sseClientFactory = sseClientFactory;
+        this.reportError = reportError;
+        this.eventSource = null;
+        this.reconnectTimer = null;
+        this.stopped = false;
+    }
+    connect() {
+        this.openEventSource();
+    }
+    disconnect() {
+        // Permanent teardown. Block any in-flight or future reconnect: a pending
+        // `onerror` triggered by the close() below — or a timer already scheduled
+        // before this call — must not re-open the source after the owning
+        // StoreManager has torn down its Database. That post-teardown reopen is
+        // what surfaces as "the database connection is closing".
+        this.stopped = true;
+        if (this.reconnectTimer != null) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.eventSource != null) {
+            this.eventSource.onerror = null;
+            this.eventSource.close();
+            this.eventSource = null;
+            this.onClose();
+        }
+    }
+    reconnect() {
+        this.openEventSource();
+    }
+    get isConnected() {
+        return this.eventSource != null;
+    }
+    buildUrl() {
+        return this.url;
+    }
+    onReconnect() { }
+    onOpen() { }
+    onClose() { }
+    openEventSource() {
+        if (this.stopped) {
+            return;
+        }
+        if (this.eventSource != null) {
+            this.eventSource.close();
+            this.eventSource = null;
+            this.onClose();
+        }
+        const url = this.buildUrl();
+        try {
+            this.eventSource = this.sseClientFactory(url);
+            this.eventSource.onmessage = (e) => {
+                try {
+                    this.onMessage(e.data);
+                }
+                catch (err) {
+                    this.reportError?.(toError(err), {
+                        kind: "ssePacketParse",
+                        url,
+                        raw: e.data,
+                    });
+                }
+            };
+            this.eventSource.onerror = () => {
+                this.eventSource?.close();
+                this.eventSource = null;
+                this.onClose();
+                this.scheduleReconnect();
+            };
+            this.onOpen();
+        }
+        catch (err) {
+            this.reportError?.(toError(err), { kind: "sseConstruction", url });
+        }
+    }
+    scheduleReconnect() {
+        if (this.stopped || this.reconnectTimer != null) {
+            return;
+        }
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.openEventSource();
+            this.onReconnect();
+        }, 3000);
+    }
+}

package/dist/core/BatchModelLoader.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Coalesces concurrent on-demand index queries into a single server call.
+ * Used by `StoreManager.getOrLoadCollection` when an `onDemandIndexBatchFetcher`
+ * is configured; otherwise the per-triple `onDemandFetcher` runs directly.
+ */
+export interface IndexQuery {
+    modelName: string;
+    indexKey: string;
+    value: string;
+}
+export type IndexBatchFetcher = (queries: IndexQuery[]) => Promise<Record<string, Record<string, unknown>[]>>;
+export declare class BatchModelLoader {
+    private fetcher;
+    private pending;
+    private flushScheduled;
+    private disposed;
+    constructor(fetcher: IndexBatchFetcher);
+    /**
+     * Schedule `query` for the next batch. The returned promise resolves with
+     * the records matching this specific triple (filtered from the per-model
+     * bag the server returns).
+     */
+    load(query: IndexQuery): Promise<Record<string, unknown>[]>;
+    /** Reject any unflushed waiters. Called from `StoreManager.teardown`. */
+    dispose(): void;
+    private flush;
+}