@astrogate/sdk 0.0.0-stage → 0.1.0

package/node_modules/@instantdb/core/dist/esm/transactionValidation.d.ts

@@ -0,0 +1,7 @@
+import { TransactionChunk } from './instatx.ts';
+import { IContainEntitiesAndLinks } from './schemaTypes.ts';
+export declare const isValidEntityId: (value: unknown) => boolean;
+export declare class TransactionValidationError extends Error {
+    constructor(message: string);
+}
+export declare const validateTransactions: (inputChunks: TransactionChunk<any, any> | TransactionChunk<any, any>[], schema?: IContainEntitiesAndLinks<any, any>) => void;

package/node_modules/@instantdb/core/dist/esm/transactionValidation.js

@@ -0,0 +1,130 @@
+import { isLookup } from './instatx.js';
+import { validate as validateUUID } from 'uuid';
+export const isValidEntityId = (value) => {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    if (isLookup(value)) {
+        return true;
+    }
+    return validateUUID(value);
+};
+export class TransactionValidationError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TransactionValidationError';
+    }
+}
+const formatAvailableOptions = (items) => items.length > 0 ? items.join(', ') : 'none';
+const createEntityNotFoundError = (entityName, availableEntities) => new TransactionValidationError(`Entity '${entityName}' does not exist in schema. Available entities: ${formatAvailableOptions(availableEntities)}`);
+const TYPE_VALIDATORS = {
+    string: (value) => typeof value === 'string',
+    number: (value) => typeof value === 'number' && !isNaN(value),
+    boolean: (value) => typeof value === 'boolean',
+    date: (value) => value instanceof Date ||
+        typeof value === 'string' ||
+        typeof value === 'number',
+    json: () => true,
+};
+const isValidValueForAttr = (value, attrDef) => {
+    if (value === null || value === undefined)
+        return true;
+    return TYPE_VALIDATORS[attrDef.valueType]?.(value) ?? false;
+};
+const validateEntityExists = (entityName, schema) => {
+    const entityDef = schema.entities[entityName];
+    if (!entityDef) {
+        throw createEntityNotFoundError(entityName, Object.keys(schema.entities));
+    }
+    return entityDef;
+};
+const validateDataOperation = (entityName, data, schema) => {
+    const entityDef = validateEntityExists(entityName, schema);
+    if (typeof data !== 'object' || data === null) {
+        throw new TransactionValidationError(`Arguments for data operation on entity '${entityName}' must be an object, but received: ${typeof data}`);
+    }
+    for (const [attrName, value] of Object.entries(data)) {
+        if (attrName === 'id')
+            continue; // id is handled specially
+        const attrDef = entityDef.attrs[attrName];
+        if (attrDef) {
+            if (!isValidValueForAttr(value, attrDef)) {
+                throw new TransactionValidationError(`Invalid value for attribute '${attrName}' in entity '${entityName}'. Expected ${attrDef.valueType}, but received: ${typeof value}`);
+            }
+        }
+    }
+};
+const validateLinkOperation = (entityName, links, schema) => {
+    const entityDef = validateEntityExists(entityName, schema);
+    if (typeof links !== 'object' || links === null) {
+        throw new TransactionValidationError(`Arguments for link operation on entity '${entityName}' must be an object, but received: ${typeof links}`);
+    }
+    for (const [linkName, linkValue] of Object.entries(links)) {
+        const link = entityDef.links[linkName];
+        if (!link) {
+            const availableLinks = Object.keys(entityDef.links);
+            throw new TransactionValidationError(`Link '${linkName}' does not exist on entity '${entityName}'. Available links: ${formatAvailableOptions(availableLinks)}`);
+        }
+        // Validate UUID format for link values
+        if (linkValue !== null && linkValue !== undefined) {
+            if (Array.isArray(linkValue)) {
+                // Handle array of UUIDs
+                for (const linkReference of linkValue) {
+                    if (!isValidEntityId(linkReference)) {
+                        throw new TransactionValidationError(`Invalid entity ID in link '${linkName}' for entity '${entityName}'. Expected a UUID or a lookup, but received: ${linkReference}`);
+                    }
+                }
+            }
+            else {
+                // Handle single UUID
+                if (!isValidEntityId(linkValue)) {
+                    throw new TransactionValidationError(`Invalid UUID in link '${linkName}' for entity '${entityName}'. Expected a UUID, but received: ${linkValue}`);
+                }
+            }
+        }
+    }
+};
+const VALIDATION_STRATEGIES = {
+    create: validateDataOperation,
+    update: validateDataOperation,
+    merge: validateDataOperation,
+    link: validateLinkOperation,
+    unlink: validateLinkOperation,
+    delete: () => { },
+};
+const validateOp = (op, schema) => {
+    if (!schema)
+        return;
+    const [action, entityName, _id, args] = op;
+    // _id should be a uuid
+    if (!Array.isArray(_id)) {
+        const isUuid = validateUUID(_id);
+        if (!isUuid) {
+            throw new TransactionValidationError(`Invalid id for entity '${entityName}'. Expected a UUID, but received: ${_id}`);
+        }
+    }
+    if (typeof entityName !== 'string') {
+        throw new TransactionValidationError(`Entity name must be a string, but received: ${typeof entityName}`);
+    }
+    const validator = VALIDATION_STRATEGIES[action];
+    if (validator && args !== undefined) {
+        validator(entityName, args, schema);
+    }
+};
+export const validateTransactions = (inputChunks, schema) => {
+    const chunks = Array.isArray(inputChunks) ? inputChunks : [inputChunks];
+    for (const txStep of chunks) {
+        if (!txStep || typeof txStep !== 'object') {
+            throw new TransactionValidationError(`Transaction chunk must be an object, but received: ${typeof txStep}`);
+        }
+        if (!Array.isArray(txStep.__ops)) {
+            throw new TransactionValidationError(`Transaction chunk must have __ops array, but received: ${typeof txStep.__ops}`);
+        }
+        for (const op of txStep.__ops) {
+            if (!Array.isArray(op)) {
+                throw new TransactionValidationError(`Transaction operation must be an array, but received: ${typeof op}`);
+            }
+            validateOp(op, schema);
+        }
+    }
+};

package/node_modules/@instantdb/core/dist/esm/utils/Deferred.d.ts

@@ -0,0 +1,8 @@
+export declare class Deferred<T = any> {
+    promise: Promise<T>;
+    _resolve: (value: T) => void;
+    _reject: (...reason: any) => void;
+    constructor();
+    resolve(value: any): void;
+    reject(reason: any): void;
+}

package/node_modules/@instantdb/core/dist/esm/utils/Deferred.js

@@ -0,0 +1,17 @@
+export class Deferred {
+    promise;
+    _resolve;
+    _reject;
+    constructor() {
+        this.promise = new Promise((resolve, reject) => {
+            this._resolve = resolve;
+            this._reject = reject;
+        });
+    }
+    resolve(value) {
+        this._resolve(value);
+    }
+    reject(reason) {
+        this._reject(reason);
+    }
+}

package/node_modules/@instantdb/core/dist/esm/utils/PersistedObject.d.ts

@@ -0,0 +1,80 @@
+import type { Logger } from './log.ts';
+export declare const META_KEY = "__meta";
+export type ObjectMeta = {
+    createdAt: number;
+    updatedAt: number;
+    size: number;
+};
+export type Meta<K extends string> = {
+    objects: Record<K, ObjectMeta>;
+};
+export type StoreInterfaceStoreName = 'kv' | 'querySubs' | 'syncSubs';
+export declare abstract class StoreInterface {
+    constructor(appId: string, storeName: StoreInterfaceStoreName);
+    abstract getItem(key: string): Promise<any>;
+    abstract removeItem(key: string): Promise<void>;
+    abstract multiSet(keyValuePairs: Array<[string, any]>): Promise<void>;
+    abstract getAllKeys(): Promise<string[]>;
+}
+export type StoreInterfaceClass = new (appId: string, storeName: StoreInterfaceStoreName) => StoreInterface;
+export type GCOpts = {
+    maxSize: number;
+    maxAgeMs: number;
+    maxEntries: number;
+};
+export type Opts<K, T, SerializedT> = {
+    persister: StoreInterface;
+    /**
+     * Merges data from storage with in-memory value on load.
+     * The value returned from merge will become the current value.
+     */
+    merge: (key: K, fromStorage: T | null | undefined, inMemoryValue: T | null | undefined) => T;
+    serialize: (key: K, input: T) => SerializedT;
+    parse: (key: K, value: SerializedT) => T;
+    objectSize: (x: SerializedT) => number;
+    logger: Logger;
+    gc: GCOpts | null | undefined;
+    saveThrottleMs?: number | null | undefined;
+    idleCallbackMaxWaitMs?: number | null | undefined;
+    preloadEntryCount?: number | null | undefined;
+};
+export declare class PersistedObject<K extends string, T, SerializedT> {
+    currentValue: Record<K, T>;
+    private _subs;
+    private _persister;
+    private _merge;
+    private serialize;
+    private parse;
+    private _saveThrottleMs;
+    private _idleCallbackMaxWaitMs;
+    private _nextSave;
+    private _nextGc;
+    private _pendingSaveKeys;
+    private _loadedKeys;
+    private _loadingKeys;
+    private _objectSize;
+    private _log;
+    onKeyLoaded: (key: string) => void | null | undefined;
+    private _version;
+    private _meta;
+    private _gcOpts;
+    constructor(opts: Opts<K, T, SerializedT>);
+    private _initMeta;
+    private _getMeta;
+    private _refreshMeta;
+    private _preloadEntries;
+    private _getFromStorage;
+    waitForKeyToLoad(k: K): Promise<Record<K, T>[K]>;
+    waitForMetaToLoad(): Promise<Meta<K> | null>;
+    unloadKey(k: K): void;
+    private _loadKey;
+    private _writeToStorage;
+    flush(): Promise<number | undefined>;
+    private _gc;
+    gc(): void;
+    private _enqueuePersist;
+    version(): number;
+    updateInPlace(f: (prev: Record<string, T>) => void): Record<string, T>;
+    subscribe(cb: (value: Record<K, T>) => void): () => void;
+    clearUnloadedKeys(): Promise<void>;
+}

package/node_modules/@instantdb/core/dist/esm/utils/PersistedObject.js

@@ -0,0 +1,448 @@
+// PersistedObjects save data outside of memory.
+//
+// When we load a persisted object, it's possible we call `set`
+// before we finish loading. To address we handle set in two ways:
+//
+// 1. Before load
+// We simply update currentValue in memory
+//
+// 2. After load
+// We update currentValue in memory and in storage
+//
+// Each PersistedObject provides it's own `onMerge`
+// function to handle the merge of data from storage and memory
+// on load
+// Uses `requestIdleCallback` if available, otherwise calls the
+// callback immediately
+import { create } from 'mutative';
+function safeIdleCallback(cb, timeout) {
+    if (typeof requestIdleCallback === 'undefined') {
+        cb();
+    }
+    else {
+        requestIdleCallback(cb, { timeout });
+    }
+}
+export const META_KEY = '__meta';
+export class StoreInterface {
+    constructor(appId, storeName) { }
+}
+export class PersistedObject {
+    currentValue;
+    _subs = [];
+    _persister;
+    _merge;
+    serialize;
+    parse;
+    _saveThrottleMs;
+    _idleCallbackMaxWaitMs;
+    _nextSave = null;
+    _nextGc = null;
+    _pendingSaveKeys = new Set();
+    _loadedKeys = new Set();
+    _loadingKeys;
+    _objectSize;
+    _log;
+    onKeyLoaded;
+    _version = 0;
+    _meta = {
+        isLoading: true,
+        onLoadCbs: [],
+        value: null,
+        error: null,
+        attempts: 0,
+    };
+    _gcOpts;
+    constructor(opts) {
+        this._persister = opts.persister;
+        this._merge = opts.merge;
+        this.serialize = opts.serialize;
+        this.parse = opts.parse;
+        this._objectSize = opts.objectSize;
+        this._log = opts.logger;
+        this._saveThrottleMs = opts.saveThrottleMs ?? 100;
+        this._idleCallbackMaxWaitMs = opts.idleCallbackMaxWaitMs ?? 1000;
+        this._gcOpts = opts.gc;
+        this.currentValue = {};
+        this._loadedKeys = new Set();
+        this._loadingKeys = {};
+        this._initMeta();
+        if (opts.preloadEntryCount) {
+            this._preloadEntries(opts.preloadEntryCount);
+        }
+    }
+    async _initMeta() {
+        if (this._meta.loadingPromise) {
+            await this._meta.loadingPromise;
+        }
+        try {
+            const p = this._persister.getItem(META_KEY);
+            this._meta.loadingPromise = p;
+            const v = await p;
+            this._meta.isLoading = false;
+            this._meta.error = null;
+            this._meta.loadingPromise = null;
+            this._meta.attempts = 0;
+            const existingObjects = this._meta.value?.objects ?? {};
+            const value = v ?? {};
+            const objects = value.objects ?? {};
+            // Merge the values from storage with in-memory values
+            this._meta.value = {
+                ...value,
+                objects: { ...existingObjects, ...objects },
+            };
+        }
+        catch (e) {
+            this._meta.error = e;
+            this._meta.attempts++;
+            this._meta.loadingPromise = null;
+        }
+    }
+    async _getMeta() {
+        if (this._meta.value) {
+            return this._meta.value;
+        }
+        if (this._meta.loadingPromise) {
+            await this._meta.loadingPromise;
+            return this._meta.value;
+        }
+        this._initMeta();
+        await this._meta.loadingPromise;
+        return this._meta.value;
+    }
+    async _refreshMeta() {
+        await this._initMeta();
+        return this._meta.value;
+    }
+    async _preloadEntries(n) {
+        const meta = await this.waitForMetaToLoad();
+        if (!meta)
+            return;
+        const entries = Object.entries(meta.objects);
+        entries.sort(([_k_a, a_meta], [_k_b, b_meta]) => {
+            return b_meta.updatedAt - a_meta.updatedAt;
+        });
+        for (const [k] of entries.slice(0, n)) {
+            this._loadKey(k);
+        }
+    }
+    async _getFromStorage(key) {
+        try {
+            const data = await this._persister.getItem(key);
+            if (!data) {
+                return data;
+            }
+            const parsed = this.parse(key, data);
+            return parsed;
+        }
+        catch (e) {
+            console.error(`Unable to read from storage for key=${key}`, e);
+            return null;
+        }
+    }
+    async waitForKeyToLoad(k) {
+        if (this._loadedKeys.has(k)) {
+            return this.currentValue[k];
+        }
+        await (this._loadingKeys[k] || this._loadKey(k));
+        return this.currentValue[k];
+    }
+    // Used for tests
+    async waitForMetaToLoad() {
+        return this._getMeta();
+    }
+    // Unloads the key so that it can be garbage collected, but does not
+    // delete it. Removes the key from currentValue.
+    unloadKey(k) {
+        this._loadedKeys.delete(k);
+        delete this._loadingKeys[k];
+        delete this.currentValue[k];
+    }
+    async _loadKey(k) {
+        if (this._loadedKeys.has(k) || k in this._loadingKeys)
+            return;
+        const p = this._getFromStorage(k);
+        this._loadingKeys[k] = p;
+        const value = await p;
+        delete this._loadingKeys[k];
+        this._loadedKeys.add(k);
+        if (value) {
+            const merged = this._merge(k, value, this.currentValue[k]);
+            if (merged) {
+                this.currentValue[k] = merged;
+            }
+        }
+        this.onKeyLoaded && this.onKeyLoaded(k);
+    }
+    // Returns a promise with a number so that we can wait for flush
+    // to finish in the tests. The number is the number of operations
+    // it performed, but it's mostly there so that typescript will warn
+    // us if we forget to retun the promise from the function.
+    _writeToStorage(opts) {
+        const promises = [];
+        const skipGc = opts?.skipGc;
+        if (this._meta.isLoading) {
+            // Wait for meta to load and try again, give it a delay so that
+            // we don't spend too much time retrying
+            const p = new Promise((resolve, reject) => {
+                setTimeout(() => this._enqueuePersist(opts
+                    ? { ...opts, attempts: (opts.attempts || 0) + 1 }
+                    : { attempts: 1 })
+                    .then(resolve)
+                    .catch(reject), 10 + (opts?.attempts ?? 0) * 1000);
+            });
+            promises.push(p);
+            return Promise.all(promises).then((vs) => vs.reduce((acc, x) => acc + x, 0));
+        }
+        const metaValue = this._meta.value;
+        if (!metaValue) {
+            // If it's not loading and we don't have the data, then there
+            // must be an error and we're not going to be able to save until
+            // the error is resolved elsewhere.
+            return Promise.resolve(0);
+        }
+        const keysToDelete = [];
+        const keysToUpdate = [];
+        for (const k of this._pendingSaveKeys) {
+            if (!(k in this.currentValue)) {
+                keysToDelete.push(k);
+                delete metaValue.objects[k];
+            }
+            else {
+                keysToUpdate.push(k);
+            }
+        }
+        for (const k of keysToDelete) {
+            const p = this._persister.removeItem(k);
+            promises.push(p.then(() => 1));
+            this._loadedKeys.delete(k);
+            this._pendingSaveKeys.delete(k);
+        }
+        const keysToLoad = [];
+        const kvPairs = [[META_KEY, metaValue]];
+        const metaObjects = metaValue.objects ?? {};
+        metaValue.objects = metaObjects;
+        for (const k of keysToUpdate) {
+            if (this._loadedKeys.has(k)) {
+                const serializedV = this.serialize(k, this.currentValue[k]);
+                kvPairs.push([k, serializedV]);
+                const size = this._objectSize(serializedV);
+                const m = metaObjects[k] ?? {
+                    createdAt: Date.now(),
+                    updatedAt: Date.now(),
+                    size,
+                };
+                m.updatedAt = Date.now();
+                m.size = size;
+                metaObjects[k] = m;
+                this._pendingSaveKeys.delete(k);
+            }
+            else {
+                keysToLoad.push(k);
+            }
+        }
+        const p = this._persister.multiSet(kvPairs);
+        promises.push(p.then(() => 1));
+        // For the keys that haven't loaded, load the key then try
+        // persisting again. We don't want to do any async work here
+        // or else we might end up saving older copies of the data to
+        // the store.
+        for (const k of keysToLoad) {
+            const p = this._loadKey(k).then(() => this._enqueuePersist(opts));
+            promises.push(p);
+        }
+        if (!skipGc) {
+            this.gc();
+        }
+        return Promise.all(promises).then((vs) => {
+            return vs.reduce((acc, x) => acc + x, 0);
+        });
+    }
+    async flush() {
+        if (!this._nextSave) {
+            return;
+        }
+        clearTimeout(this._nextSave);
+        this._nextSave = null;
+        const p = this._writeToStorage();
+        return p;
+    }
+    async _gc() {
+        if (!this._gcOpts) {
+            return;
+        }
+        const keys = new Set(await this._persister.getAllKeys());
+        keys.delete(META_KEY);
+        // Keys we can't delete
+        const sacredKeys = new Set(Object.keys(this.currentValue));
+        for (const k of Object.keys(this._loadingKeys)) {
+            sacredKeys.add(k);
+        }
+        for (const k of this._loadedKeys) {
+            sacredKeys.add(k);
+        }
+        // Refresh meta from the store so that we're less likely to
+        // clobber data from other tabs
+        const meta = await this._refreshMeta();
+        if (!meta) {
+            this._log.info('Could not gc because we were not able to load meta');
+            return;
+        }
+        const promises = [];
+        const deets = {
+            gcOpts: this._gcOpts,
+            keys,
+            sacredKeys,
+            removed: [],
+            metaRemoved: [],
+            removedMissingCount: 0,
+            removedOldCount: 0,
+            removedThresholdCount: 0,
+            removedSizeCount: 0,
+        };
+        // First, remove all keys we don't know about
+        for (const key of keys) {
+            if (sacredKeys.has(key) || key in meta.objects) {
+                continue;
+            }
+            this._log.info('Lost track of key in meta', key);
+            promises.push(this._persister.removeItem(key));
+            deets.removed.push(key);
+            deets.removedMissingCount++;
+        }
+        // Remove anything over the max age
+        const now = Date.now();
+        for (const [k, m] of Object.entries(meta.objects)) {
+            if (!sacredKeys.has(k) &&
+                m.updatedAt < now - this._gcOpts.maxAgeMs) {
+                promises.push(this._persister.removeItem(k));
+                delete meta.objects[k];
+                deets.removed.push(k);
+                deets.removedOldCount++;
+            }
+        }
+        // Keep queries under max queries
+        const maxEntries = Object.entries(meta.objects);
+        maxEntries.sort(([_k_a, a_meta], [_k_b, b_meta]) => {
+            return a_meta.updatedAt - b_meta.updatedAt;
+        });
+        const deletableMaxEntries = maxEntries.filter(([x]) => !sacredKeys.has(x));
+        if (maxEntries.length > this._gcOpts.maxEntries) {
+            for (const [k] of deletableMaxEntries.slice(0, maxEntries.length - this._gcOpts.maxEntries)) {
+                promises.push(this._persister.removeItem(k));
+                delete meta.objects[k];
+                deets.removed.push(k);
+                deets.removedThresholdCount++;
+            }
+        }
+        // Remove oldest entries until we are under max size
+        const delEntries = Object.entries(meta.objects);
+        delEntries.sort(([_k_a, a_meta], [_k_b, b_meta]) => {
+            return a_meta.updatedAt - b_meta.updatedAt;
+        });
+        const deletableDelEntries = delEntries.filter(([x]) => !sacredKeys.has(x));
+        let currentSize = delEntries.reduce((acc, [_k, m]) => {
+            return acc + m.size;
+        }, 0);
+        while (currentSize > 0 &&
+            currentSize > this._gcOpts.maxSize &&
+            deletableDelEntries.length) {
+            const [[k, m]] = deletableDelEntries.splice(0, 1);
+            currentSize -= m.size;
+            promises.push(this._persister.removeItem(k));
+            delete meta.objects[k];
+            deets.removed.push(k);
+            deets.removedSizeCount++;
+        }
+        // Update meta to remove keys that are no longer in the store
+        for (const k of Object.keys(meta.objects)) {
+            if (!keys.has(k) && !sacredKeys.has(k)) {
+                delete meta.objects[k];
+            }
+        }
+        if (deets.removed.length || deets.metaRemoved.length) {
+            // Trigger a flush of the meta
+            promises.push(this._enqueuePersist({ skipGc: true }));
+        }
+        this._log.info('Completed GC', deets);
+        await Promise.all(promises);
+        return deets;
+    }
+    // Schedules a GC to run in one minute (unless it is already scheduled)
+    gc() {
+        if (this._nextGc) {
+            return;
+        }
+        this._nextGc = setTimeout(() => {
+            safeIdleCallback(() => {
+                this._nextGc = null;
+                this._gc().catch((e) => this._log.error('Persisted Object GC Failed:', e));
+            }, 30 * 1000);
+        }, 
+        // 1 minute + some jitter to keep multiple tabs from running at same time
+        1000 * 60 + Math.random() * 500);
+    }
+    _enqueuePersist(opts) {
+        return new Promise((resolve, reject) => {
+            if (this._nextSave) {
+                resolve(0);
+                return;
+            }
+            this._nextSave = setTimeout(() => {
+                safeIdleCallback(() => {
+                    this._nextSave = null;
+                    this._writeToStorage(opts).then(resolve).catch(reject);
+                }, this._idleCallbackMaxWaitMs);
+            }, this._saveThrottleMs);
+        });
+    }
+    version() {
+        return this._version;
+    }
+    // Takes a function that updates the store in place.
+    // Uses `mutative` to get a list of keys that were changed
+    // so that we know which entries we need to persist to the store.
+    updateInPlace(f) {
+        this._version++;
+        const [state, patches] = create(this.currentValue, f, {
+            enablePatches: true,
+        });
+        for (const patch of patches) {
+            const k = patch.path[0];
+            if (k && typeof k === 'string') {
+                this._pendingSaveKeys.add(k);
+                if (!this._loadedKeys.has(k)) {
+                    this._loadKey(k);
+                }
+            }
+        }
+        this.currentValue = state;
+        this._enqueuePersist();
+        for (const cb of this._subs) {
+            cb(this.currentValue);
+        }
+        return state;
+    }
+    subscribe(cb) {
+        this._subs.push(cb);
+        cb(this.currentValue);
+        return () => {
+            this._subs = this._subs.filter((x) => x !== cb);
+        };
+    }
+    // Removes any keys that we haven't loaded--used when
+    // changing users to make sure we clean out all user data
+    async clearUnloadedKeys() {
+        let needsPersist = false;
+        for (const key of await this._persister.getAllKeys()) {
+            if (key === META_KEY || key in this.currentValue) {
+                continue;
+            }
+            this._pendingSaveKeys.add(key);
+            needsPersist = true;
+        }
+        if (needsPersist) {
+            await this._enqueuePersist();
+        }
+    }
+}

package/node_modules/@instantdb/core/dist/esm/utils/dates.d.ts

@@ -0,0 +1 @@
+export declare function coerceToDate(x: unknown): Date | null | undefined;