@party-stack/foundry-ontology 0.18.0 → 0.19.0

package/lib/adapter/objectCollectionOptions.js

@@ -1,569 +1,482 @@
-import { OntologyObjectsV2, ObjectTypesV2, } from "@osdk/foundry.ontologies";
+import { fromPagination, toArray } from "../utils/AsyncIterable.js";
+import { convertLoadSubsetFilter, convertLoadSubsetOrderBy, isAlwaysFalseFilter } from "./convertLoadSubsetOptions.js";
+import { ObjectTypesV2, OntologyObjectsV2 } from "@osdk/foundry.ontologies";
 import { getObjectSetWatcherManager } from "@party-stack/foundry-object-set-watcher";
-import { BasicIndex, DeduplicatedLoadSubset, } from "@tanstack/db";
+import { BasicIndex, DeduplicatedLoadSubset } from "@tanstack/db";
 import { Store } from "@tanstack/store";
-import * as AsyncIterable from "../utils/AsyncIterable.js";
-import { convertLoadSubsetFilter, convertLoadSubsetOrderBy, isAlwaysFalseFilter, } from "./convertLoadSubsetOptions.js";
-const COLLECTION_SYNC_TIMEOUT_MS = 5_000;
-class TimeoutWaitingForOperationIdError extends Error {
-    constructor(operationId, objectType) {
-        super(`Timed out waiting for Foundry operation ${operationId} to sync for ${objectType}.`);
-        this.name = "TimeoutWaitingForOperationIdError";
-    }
-}
-class ObjectCollectionSyncAbortedError extends Error {
-    constructor(objectType) {
-        super(`Foundry sync for ${objectType} stopped before the operation was observed.`);
-        this.name = "ObjectCollectionSyncAbortedError";
-    }
-}
-// ---------------------------------------------------------------------------
-// Edit history helpers
-// ---------------------------------------------------------------------------
-const EDIT_HISTORY_PAGE_SIZE = 1_000;
+//#region src/adapter/objectCollectionOptions.ts
+const COLLECTION_SYNC_TIMEOUT_MS = 5e3;
+var TimeoutWaitingForOperationIdError = class extends Error {
+	constructor(operationId, objectType) {
+		super(`Timed out waiting for Foundry operation ${operationId} to sync for ${objectType}.`);
+		this.name = "TimeoutWaitingForOperationIdError";
+	}
+};
+var ObjectCollectionSyncAbortedError = class extends Error {
+	constructor(objectType) {
+		super(`Foundry sync for ${objectType} stopped before the operation was observed.`);
+		this.name = "ObjectCollectionSyncAbortedError";
+	}
+};
+const EDIT_HISTORY_PAGE_SIZE = 1e3;
 const EDIT_HISTORY_CURSOR_METADATA_KEY = "foundry.editHistoryCursor";
 const EDIT_HISTORY_CURSOR_VERSION = 1;
-function createEditHistoryCursor(timestamp = new Date().toISOString()) {
-    return { timestamp, seenEntryKeysAtTimestamp: new Set() };
+function createEditHistoryCursor(timestamp = (/* @__PURE__ */ new Date()).toISOString()) {
+	return {
+		timestamp,
+		seenEntryKeysAtTimestamp: /* @__PURE__ */ new Set()
+	};
 }
 function cloneEditHistoryCursor(cursor) {
-    return {
-        timestamp: cursor.timestamp,
-        seenEntryKeysAtTimestamp: new Set(cursor.seenEntryKeysAtTimestamp),
-    };
+	return {
+		timestamp: cursor.timestamp,
+		seenEntryKeysAtTimestamp: new Set(cursor.seenEntryKeysAtTimestamp)
+	};
 }
 function serializeEditHistoryCursor(cursor) {
-    return {
-        version: EDIT_HISTORY_CURSOR_VERSION,
-        timestamp: cursor.timestamp,
-        seenEntryKeysAtTimestamp: [...cursor.seenEntryKeysAtTimestamp].sort(),
-    };
+	return {
+		version: EDIT_HISTORY_CURSOR_VERSION,
+		timestamp: cursor.timestamp,
+		seenEntryKeysAtTimestamp: [...cursor.seenEntryKeysAtTimestamp].sort()
+	};
 }
 function deserializeEditHistoryCursor(value) {
-    if (!isPlainObject(value) ||
-        value.version !== EDIT_HISTORY_CURSOR_VERSION ||
-        typeof value.timestamp !== "string" ||
-        !Array.isArray(value.seenEntryKeysAtTimestamp) ||
-        !value.seenEntryKeysAtTimestamp.every((key) => typeof key === "string")) {
-        return undefined;
-    }
-    return {
-        timestamp: value.timestamp,
-        seenEntryKeysAtTimestamp: new Set(value.seenEntryKeysAtTimestamp),
-    };
+	if (!isPlainObject(value) || value.version !== EDIT_HISTORY_CURSOR_VERSION || typeof value.timestamp !== "string" || !Array.isArray(value.seenEntryKeysAtTimestamp) || !value.seenEntryKeysAtTimestamp.every((key) => typeof key === "string")) return;
+	return {
+		timestamp: value.timestamp,
+		seenEntryKeysAtTimestamp: new Set(value.seenEntryKeysAtTimestamp)
+	};
 }
 function editHistoryCursorsEqual(left, right) {
-    return (left.timestamp === right.timestamp &&
-        left.seenEntryKeysAtTimestamp.size === right.seenEntryKeysAtTimestamp.size &&
-        [...left.seenEntryKeysAtTimestamp].every((key) => right.seenEntryKeysAtTimestamp.has(key)));
+	return left.timestamp === right.timestamp && left.seenEntryKeysAtTimestamp.size === right.seenEntryKeysAtTimestamp.size && [...left.seenEntryKeysAtTimestamp].every((key) => right.seenEntryKeysAtTimestamp.has(key));
 }
 function canonicalizeJsonValue(value) {
-    if (Array.isArray(value))
-        return value.map(canonicalizeJsonValue);
-    if (isPlainObject(value)) {
-        return Object.fromEntries(Object.keys(value)
-            .sort()
-            .map((key) => [key, canonicalizeJsonValue(value[key])]));
-    }
-    return value;
+	if (Array.isArray(value)) return value.map(canonicalizeJsonValue);
+	if (isPlainObject(value)) return Object.fromEntries(Object.keys(value).sort().map((key) => [key, canonicalizeJsonValue(value[key])]));
+	return value;
 }
 function getEditHistoryEntryKey(entry) {
-    return JSON.stringify(canonicalizeJsonValue({
-        objectPrimaryKey: entry.objectPrimaryKey,
-        operationId: entry.operationId,
-        timestamp: entry.timestamp,
-        edit: entry.edit,
-    }));
+	return JSON.stringify(canonicalizeJsonValue({
+		objectPrimaryKey: entry.objectPrimaryKey,
+		operationId: entry.operationId,
+		timestamp: entry.timestamp,
+		edit: entry.edit
+	}));
 }
 function shouldProcessEditHistoryEntry(cursor, entry) {
-    if (entry.timestamp < cursor.timestamp)
-        return false;
-    if (entry.timestamp === cursor.timestamp) {
-        return !cursor.seenEntryKeysAtTimestamp.has(getEditHistoryEntryKey(entry));
-    }
-    return true;
+	if (entry.timestamp < cursor.timestamp) return false;
+	if (entry.timestamp === cursor.timestamp) return !cursor.seenEntryKeysAtTimestamp.has(getEditHistoryEntryKey(entry));
+	return true;
 }
 function advanceEditHistoryCursor(cursor, entry) {
-    const entryKey = getEditHistoryEntryKey(entry);
-    if (entry.timestamp > cursor.timestamp) {
-        cursor.timestamp = entry.timestamp;
-        cursor.seenEntryKeysAtTimestamp.clear();
-    }
-    cursor.seenEntryKeysAtTimestamp.add(entryKey);
+	const entryKey = getEditHistoryEntryKey(entry);
+	if (entry.timestamp > cursor.timestamp) {
+		cursor.timestamp = entry.timestamp;
+		cursor.seenEntryKeysAtTimestamp.clear();
+	}
+	cursor.seenEntryKeysAtTimestamp.add(entryKey);
 }
 function getPrimaryKeyValue(primaryKey, primaryKeyProperty, decodeEditObject) {
-    const values = Object.values(primaryKey);
-    if (values.length !== 1) {
-        throw new Error("Foundry object collections currently only support single-field primary keys.");
-    }
-    const value = decodeEditObject({
-        [primaryKeyProperty]: values[0],
-    })[primaryKeyProperty];
-    if (typeof value !== "string" && typeof value !== "number") {
-        throw new Error("Foundry object collections currently only support string or number primary keys.");
-    }
-    return value;
+	const values = Object.values(primaryKey);
+	if (values.length !== 1) throw new Error("Foundry object collections currently only support single-field primary keys.");
+	const value = decodeEditObject({ [primaryKeyProperty]: values[0] })[primaryKeyProperty];
+	if (typeof value !== "string" && typeof value !== "number") throw new Error("Foundry object collections currently only support string or number primary keys.");
+	return value;
 }
 function isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
+	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-// ---------------------------------------------------------------------------
-// Foundry object fetching
-// ---------------------------------------------------------------------------
 async function fetchFoundryObjects(client, objectType, selectedProperties, opts, decodeObject = (object) => object) {
-    opts.signal?.throwIfAborted();
-    const offset = Math.max(0, Math.trunc(opts.offset ?? 0));
-    const limit = opts.limit === undefined ? undefined : Math.max(0, Math.trunc(opts.limit));
-    if (limit === 0)
-        return [];
-    let where = convertLoadSubsetFilter(opts.where);
-    if (isAlwaysFalseFilter(where) || (where?.type === "in" && where.value.length === 0)) {
-        return [];
-    }
-    if (opts.cursor?.whereFrom) {
-        const cursorWhere = convertLoadSubsetFilter(opts.cursor.whereFrom);
-        if (isAlwaysFalseFilter(cursorWhere)) {
-            return [];
-        }
-        if (cursorWhere) {
-            where = where ? { type: "and", value: [where, cursorWhere] } : cursorWhere;
-        }
-    }
-    const requestClient = opts.signal
-        ? {
-            ...client,
-            fetch: (input, init) => client.fetch(input, {
-                ...init,
-                signal: opts.signal,
-            }),
-        }
-        : client;
-    const results = await AsyncIterable.toArray(AsyncIterable.fromPagination((pageSize, pageToken) => OntologyObjectsV2.search(requestClient, client.ontologyRid, objectType, {
-        snapshot: true,
-        where,
-        excludeRid: true,
-        select: selectedProperties,
-        selectV2: [],
-        pageSize,
-        pageToken,
-        orderBy: convertLoadSubsetOrderBy(opts.orderBy),
-    }), (page) => page.nextPageToken, (page) => page.data, 10_000, limit === undefined ? undefined : offset + limit));
-    opts.signal?.throwIfAborted();
-    return results
-        .slice(offset, limit === undefined ? undefined : offset + limit)
-        .map(decodeObject);
+	opts.signal?.throwIfAborted();
+	const offset = Math.max(0, Math.trunc(opts.offset ?? 0));
+	const limit = opts.limit === void 0 ? void 0 : Math.max(0, Math.trunc(opts.limit));
+	if (limit === 0) return [];
+	let where = convertLoadSubsetFilter(opts.where);
+	if (isAlwaysFalseFilter(where) || where?.type === "in" && where.value.length === 0) return [];
+	if (opts.cursor?.whereFrom) {
+		const cursorWhere = convertLoadSubsetFilter(opts.cursor.whereFrom);
+		if (isAlwaysFalseFilter(cursorWhere)) return [];
+		if (cursorWhere) where = where ? {
+			type: "and",
+			value: [where, cursorWhere]
+		} : cursorWhere;
+	}
+	const requestClient = opts.signal ? {
+		...client,
+		fetch: (input, init) => client.fetch(input, {
+			...init,
+			signal: opts.signal
+		})
+	} : client;
+	const results = await toArray(fromPagination((pageSize, pageToken) => OntologyObjectsV2.search(requestClient, client.ontologyRid, objectType, {
+		snapshot: true,
+		where,
+		excludeRid: true,
+		select: selectedProperties,
+		selectV2: [],
+		pageSize,
+		pageToken,
+		orderBy: convertLoadSubsetOrderBy(opts.orderBy)
+	}), (page) => page.nextPageToken, (page) => page.data, 1e4, limit === void 0 ? void 0 : offset + limit));
+	opts.signal?.throwIfAborted();
+	return results.slice(offset, limit === void 0 ? void 0 : offset + limit).map(decodeObject);
 }
 function createSyncConfig(client, objectType, primaryKeyProperty, selectedProperties, decodeObject = (object) => object, decodeEditObject = decodeObject, live = true) {
-    const seenOperationIds = new Store(new Set());
-    const syncDisposed = new Store(false);
-    const directWebsocketSyncVersion = new Store(0);
-    let editHistoryUnavailable = false;
-    let requestFullRefresh;
-    let requestEditHistoryCatchUp;
-    const awaitOperationId = async (operationId, timeout = COLLECTION_SYNC_TIMEOUT_MS) => {
-        if (typeof operationId !== "string" || operationId.length === 0) {
-            throw new Error("Foundry operationId must be a non-empty string.");
-        }
-        if (seenOperationIds.state.has(operationId)) {
-            return;
-        }
-        if (syncDisposed.state) {
-            throw new ObjectCollectionSyncAbortedError(objectType);
-        }
-        if (!requestEditHistoryCatchUp) {
-            // An on-demand collection has no local state to confirm until its sync starts.
-            // TODO: Track sync activity and edit-history availability separately. If sync is
-            // active but edit-history catch-up is unavailable, request and await a full refresh.
-            return;
-        }
-        const directSyncVersionAtStart = directWebsocketSyncVersion.state;
-        requestEditHistoryCatchUp();
-        return new Promise((resolve, reject) => {
-            const cleanup = () => {
-                clearTimeout(timeoutId);
-                seenOperationIdsSubscription.unsubscribe();
-                directWebsocketSyncVersionSubscription.unsubscribe();
-                disposedSubscription.unsubscribe();
-            };
-            const timeoutId = setTimeout(() => {
-                cleanup();
-                reject(new TimeoutWaitingForOperationIdError(operationId, objectType));
-            }, timeout);
-            const seenOperationIdsSubscription = seenOperationIds.subscribe(() => {
-                if (seenOperationIds.state.has(operationId)) {
-                    cleanup();
-                    resolve();
-                }
-            });
-            const directWebsocketSyncVersionSubscription = directWebsocketSyncVersion.subscribe(() => {
-                if (editHistoryUnavailable &&
-                    directWebsocketSyncVersion.state >
-                        directSyncVersionAtStart) {
-                    cleanup();
-                    resolve();
-                }
-            });
-            const disposedSubscription = syncDisposed.subscribe(() => {
-                if (syncDisposed.state) {
-                    cleanup();
-                    reject(new ObjectCollectionSyncAbortedError(objectType));
-                }
-            });
-        });
-    };
-    const utils = { awaitOperationId };
-    const sync = {
-        sync: (params) => {
-            const { begin, write, commit, markError, markReady, truncate, } = params;
-            const collectionMetadata = params.metadata?.collection;
-            syncDisposed.setState(() => false);
-            let disposed = false;
-            const restoredEditHistoryCursor = deserializeEditHistoryCursor(collectionMetadata?.get(EDIT_HISTORY_CURSOR_METADATA_KEY));
-            let editHistoryCursor = restoredEditHistoryCursor ?? createEditHistoryCursor();
-            let initialCommit = true;
-            if (!restoredEditHistoryCursor) {
-                if (collectionMetadata) {
-                    begin();
-                    collectionMetadata.set(EDIT_HISTORY_CURSOR_METADATA_KEY, serializeEditHistoryCursor(editHistoryCursor));
-                    initialCommit = commit();
-                }
-            }
-            let catchUpRequested = false;
-            let catchUpTask;
-            let pendingDirectWatcherUpdates = [];
-            let fullRefreshRequested = false;
-            let fullRefreshTask;
-            const getObjectKey = (object) => object[primaryKeyProperty];
-            const getWatcherObjectKey = (object) => {
-                const key = object[primaryKeyProperty] ?? object.__primaryKey;
-                if (typeof key !== "string" && typeof key !== "number") {
-                    throw new Error(`Foundry websocket update for ${objectType} did not include a supported primary key.`);
-                }
-                return key;
-            };
-            const upsertObject = (object) => {
-                const key = getObjectKey(object);
-                const exists = params.collection.has(key);
-                const existing = exists ? params.collection.get(key) : undefined;
-                write({
-                    type: exists ? "update" : "insert",
-                    value: existing
-                        ? {
-                            ...existing,
-                            ...object,
-                        }
-                        : object,
-                });
-            };
-            const deleteObjectByKey = (key) => {
-                write({ type: "delete", key });
-                return true;
-            };
-            const fetchEditHistoryPage = (body) => ObjectTypesV2.getEditsHistory(client, client.ontologyRid, objectType, body, 
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            {
-                preview: true,
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            });
-            const decodeEditProperties = (properties, primaryKey) => decodeEditObject({
-                ...properties,
-                [primaryKeyProperty]: primaryKey,
-            });
-            const decodeWatcherObject = (object, primaryKey) => decodeObject({
-                ...object,
-                [primaryKeyProperty]: primaryKey,
-            });
-            const applyDirectWatcherUpdates = async (updates) => {
-                const pendingMutations = new Map();
-                let observedObjectUpdate = false;
-                for (const update of updates) {
-                    if (update.type !== "object")
-                        continue;
-                    observedObjectUpdate = true;
-                    const object = update.object;
-                    const primaryKey = getWatcherObjectKey(object);
-                    switch (update.state) {
-                        case "ADDED_OR_UPDATED":
-                            pendingMutations.set(primaryKey, {
-                                type: "upsert",
-                                object: decodeWatcherObject(object, primaryKey),
-                            });
-                            break;
-                        case "REMOVED":
-                            pendingMutations.set(primaryKey, { type: "delete" });
-                            break;
-                    }
-                }
-                let transactionStarted = false;
-                for (const [primaryKey, mutation] of pendingMutations) {
-                    if (!transactionStarted) {
-                        begin();
-                        transactionStarted = true;
-                    }
-                    if (mutation.type === "delete") {
-                        deleteObjectByKey(primaryKey);
-                    }
-                    else {
-                        upsertObject(mutation.object);
-                    }
-                }
-                const receipt = transactionStarted ? commit() : true;
-                if (observedObjectUpdate) {
-                    directWebsocketSyncVersion.setState((version) => version + 1);
-                }
-                if (receipt !== true)
-                    await receipt;
-            };
-            const switchToDirectWebsocketMode = (error) => {
-                if (!editHistoryUnavailable) {
-                    const errorMessage = error instanceof Error ? error.message : error;
-                    console.warn(`Edit history catch-up failed for ${objectType}; falling back to direct websocket updates.`, errorMessage);
-                    editHistoryUnavailable = true;
-                }
-                if (pendingDirectWatcherUpdates.length >
-                    0) {
-                    const updates = pendingDirectWatcherUpdates;
-                    pendingDirectWatcherUpdates = [];
-                    void applyDirectWatcherUpdates(updates).catch((applyError) => {
-                        console.warn(`Failed to apply direct Foundry updates for ${objectType}.`, applyError);
-                    });
-                }
-                requestFullRefresh?.();
-            };
-            const catchUpFromEditHistory = async () => {
-                const nextEditHistoryCursor = cloneEditHistoryCursor(editHistoryCursor);
-                const pendingMutations = new Map();
-                const newOperationIds = new Set();
-                for await (const entry of AsyncIterable.fromPagination((pageSize, pageToken) => fetchEditHistoryPage({
-                    filters: {
-                        type: "timestampFilter",
-                        startTime: nextEditHistoryCursor.timestamp,
-                    },
-                    includeAllPreviousProperties: true,
-                    pageSize,
-                    pageToken,
-                    sortOrder: "oldest_first",
-                }), (page) => page.nextPageToken, (page) => page.data, EDIT_HISTORY_PAGE_SIZE)) {
-                    if (disposed)
-                        break;
-                    if (!shouldProcessEditHistoryEntry(nextEditHistoryCursor, entry))
-                        continue;
-                    advanceEditHistoryCursor(nextEditHistoryCursor, entry);
-                    newOperationIds.add(entry.operationId);
-                    const primaryKey = getPrimaryKeyValue(entry.objectPrimaryKey, primaryKeyProperty, decodeEditObject);
-                    switch (entry.edit.type) {
-                        case "createEdit":
-                        case "modifyEdit":
-                            pendingMutations.set(primaryKey, {
-                                type: "upsert",
-                                object: decodeEditProperties(entry.edit.properties, primaryKey),
-                            });
-                            break;
-                        case "deleteEdit":
-                            pendingMutations.set(primaryKey, { type: "delete" });
-                            break;
-                    }
-                }
-                if (disposed)
-                    return;
-                const checkpointChanged = !editHistoryCursorsEqual(editHistoryCursor, nextEditHistoryCursor);
-                let transactionStarted = false;
-                const ensureTransaction = () => {
-                    if (transactionStarted)
-                        return;
-                    begin();
-                    transactionStarted = true;
-                };
-                for (const [primaryKey, mutation] of pendingMutations) {
-                    ensureTransaction();
-                    if (mutation.type === "delete") {
-                        deleteObjectByKey(primaryKey);
-                    }
-                    else {
-                        upsertObject(mutation.object);
-                    }
-                }
-                if (checkpointChanged && collectionMetadata) {
-                    ensureTransaction();
-                    collectionMetadata.set(EDIT_HISTORY_CURSOR_METADATA_KEY, serializeEditHistoryCursor(nextEditHistoryCursor));
-                }
-                const receipt = transactionStarted ? commit() : true;
-                if (checkpointChanged) {
-                    editHistoryCursor = nextEditHistoryCursor;
-                }
-                if (newOperationIds.size > 0) {
-                    seenOperationIds.setState((current) => new Set([
-                        ...current,
-                        ...newOperationIds,
-                    ]));
-                }
-                pendingDirectWatcherUpdates = [];
-                if (receipt !== true)
-                    await receipt;
-            };
-            const refreshAllFromSource = async () => {
-                const objects = await fetchFoundryObjects(client, objectType, selectedProperties, {}, decodeObject);
-                if (disposed)
-                    return;
-                begin();
-                truncate();
-                for (const object of objects) {
-                    write({
-                        type: "insert",
-                        value: object,
-                    });
-                }
-                const receipt = commit();
-                if (pendingDirectWatcherUpdates.length > 0) {
-                    const updates = pendingDirectWatcherUpdates;
-                    pendingDirectWatcherUpdates = [];
-                    await applyDirectWatcherUpdates(updates);
-                }
-                directWebsocketSyncVersion.setState((version) => version + 1);
-                if (receipt !== true)
-                    await receipt;
-            };
-            requestFullRefresh = () => {
-                fullRefreshRequested = true;
-                if (fullRefreshTask)
-                    return;
-                fullRefreshTask = (async () => {
-                    while (fullRefreshRequested && !disposed) {
-                        fullRefreshRequested = false;
-                        await refreshAllFromSource();
-                    }
-                })()
-                    .catch((error) => {
-                    console.warn(`Failed full Foundry refresh for ${objectType}.`, error);
-                })
-                    .finally(() => {
-                    fullRefreshTask = undefined;
-                    if (fullRefreshRequested && !disposed) {
-                        requestFullRefresh?.();
-                    }
-                });
-            };
-            requestEditHistoryCatchUp = () => {
-                if (editHistoryUnavailable) {
-                    return;
-                }
-                catchUpRequested = true;
-                if (catchUpTask)
-                    return;
-                catchUpTask = (async () => {
-                    while (catchUpRequested && !disposed) {
-                        catchUpRequested = false;
-                        await catchUpFromEditHistory();
-                    }
-                })()
-                    .catch((error) => {
-                    switchToDirectWebsocketMode(error);
-                })
-                    .finally(() => {
-                    catchUpTask = undefined;
-                    if (catchUpRequested && !disposed) {
-                        requestEditHistoryCatchUp?.();
-                    }
-                });
-            };
-            const loadSubset = async (opts) => {
-                const objects = await fetchFoundryObjects(client, objectType, selectedProperties, opts, decodeObject);
-                if (objects.length > 0) {
-                    begin();
-                    for (const object of objects) {
-                        upsertObject(object);
-                    }
-                    const receipt = commit(opts.signal);
-                    if (receipt !== true)
-                        await receipt;
-                }
-            };
-            const loadSubsetDedupe = new DeduplicatedLoadSubset({ loadSubset });
-            const unsubscribe = live
-                ? getObjectSetWatcherManager(client).subscribe({ type: "base", objectType }, (message) => {
-                    switch (message.type) {
-                        case "change": {
-                            if (editHistoryUnavailable) {
-                                if (fullRefreshTask) {
-                                    pendingDirectWatcherUpdates.push(...message.updates);
-                                }
-                                else {
-                                    void applyDirectWatcherUpdates(message.updates).catch((error) => {
-                                        console.warn(`Failed to apply direct Foundry updates for ${objectType}.`, error);
-                                        requestFullRefresh?.();
-                                    });
-                                }
-                            }
-                            else {
-                                pendingDirectWatcherUpdates.push(...message.updates);
-                                requestEditHistoryCatchUp?.();
-                            }
-                            break;
-                        }
-                        case "refresh": {
-                            if (editHistoryUnavailable) {
-                                requestFullRefresh?.();
-                            }
-                            else {
-                                requestEditHistoryCatchUp?.();
-                            }
-                            break;
-                        }
-                        case "state": {
-                            if (message.status !== "open")
-                                break;
-                            if (editHistoryUnavailable) {
-                                requestFullRefresh?.();
-                            }
-                            else {
-                                requestEditHistoryCatchUp?.();
-                            }
-                            break;
-                        }
-                    }
-                })
-                : () => { };
-            // start task here, cleanup can stop it
-            // in that task:
-            // - spawn object set subscription, which sends messages to catch up
-            // - actions sends messages to catch up
-            if (initialCommit === true) {
-                markReady();
-            }
-            else {
-                void initialCommit.then(markReady, markError);
-            }
-            return {
-                loadSubset: loadSubsetDedupe.loadSubset,
-                cleanup: () => {
-                    disposed = true;
-                    requestEditHistoryCatchUp = undefined;
-                    requestFullRefresh = undefined;
-                    syncDisposed.setState(() => true);
-                    unsubscribe();
-                    loadSubsetDedupe.reset();
-                },
-            };
-        },
-    };
-    return { sync, utils };
+	const seenOperationIds = new Store(/* @__PURE__ */ new Set());
+	const syncDisposed = new Store(false);
+	const fullSourceRefreshVersion = new Store(0);
+	let editHistoryUnavailable = false;
+	let requestFullRefresh;
+	const refresh = async () => {
+		if (!requestFullRefresh || syncDisposed.state) throw new ObjectCollectionSyncAbortedError(objectType);
+		await requestFullRefresh();
+	};
+	const refreshInBackground = () => {
+		refresh().catch((error) => {
+			console.warn(`Failed full Foundry refresh for ${objectType}.`, error);
+		});
+	};
+	let requestEditHistoryCatchUp;
+	const awaitOperationId = async (operationId, timeout = COLLECTION_SYNC_TIMEOUT_MS) => {
+		if (typeof operationId !== "string" || operationId.length === 0) throw new Error("Foundry operationId must be a non-empty string.");
+		if (seenOperationIds.state.has(operationId)) return;
+		if (syncDisposed.state) throw new ObjectCollectionSyncAbortedError(objectType);
+		if (!requestEditHistoryCatchUp) return;
+		const refreshVersionAtStart = fullSourceRefreshVersion.state;
+		const historyUnavailableAtStart = editHistoryUnavailable;
+		return new Promise((resolve, reject) => {
+			const cleanup = () => {
+				clearTimeout(timeoutId);
+				seenOperationIdsSubscription.unsubscribe();
+				fullSourceRefreshVersionSubscription.unsubscribe();
+				disposedSubscription.unsubscribe();
+			};
+			const timeoutId = setTimeout(() => {
+				cleanup();
+				reject(new TimeoutWaitingForOperationIdError(operationId, objectType));
+			}, timeout);
+			const seenOperationIdsSubscription = seenOperationIds.subscribe(() => {
+				if (seenOperationIds.state.has(operationId)) {
+					cleanup();
+					resolve();
+				}
+			});
+			const fullSourceRefreshVersionSubscription = fullSourceRefreshVersion.subscribe(() => {
+				if (!historyUnavailableAtStart && editHistoryUnavailable && fullSourceRefreshVersion.state > refreshVersionAtStart) {
+					cleanup();
+					resolve();
+				}
+			});
+			const disposedSubscription = syncDisposed.subscribe(() => {
+				if (syncDisposed.state) {
+					cleanup();
+					reject(new ObjectCollectionSyncAbortedError(objectType));
+				}
+			});
+			if (editHistoryUnavailable) refresh().then(() => {
+				cleanup();
+				resolve();
+			}, (error) => {
+				cleanup();
+				reject(error);
+			});
+			else requestEditHistoryCatchUp?.();
+		});
+	};
+	return {
+		sync: { sync: (params) => {
+			const { begin, write, commit, markError, markReady, truncate } = params;
+			const collectionMetadata = params.metadata?.collection;
+			syncDisposed.setState(() => false);
+			let disposed = false;
+			const restoredEditHistoryCursor = deserializeEditHistoryCursor(collectionMetadata?.get(EDIT_HISTORY_CURSOR_METADATA_KEY));
+			let editHistoryCursor = restoredEditHistoryCursor ?? createEditHistoryCursor();
+			let initialCommit = true;
+			if (!restoredEditHistoryCursor) {
+				if (collectionMetadata) {
+					begin();
+					collectionMetadata.set(EDIT_HISTORY_CURSOR_METADATA_KEY, serializeEditHistoryCursor(editHistoryCursor));
+					initialCommit = commit();
+				}
+			}
+			let catchUpRequested = false;
+			let catchUpTask;
+			let pendingDirectWatcherUpdates = [];
+			let fullRefreshRequested = false;
+			let fullRefreshTask;
+			const getObjectKey = (object) => object[primaryKeyProperty];
+			const getWatcherObjectKey = (object) => {
+				const key = object[primaryKeyProperty] ?? object.__primaryKey;
+				if (typeof key !== "string" && typeof key !== "number") throw new Error(`Foundry websocket update for ${objectType} did not include a supported primary key.`);
+				return key;
+			};
+			const upsertObject = (object) => {
+				const key = getObjectKey(object);
+				const exists = params.collection.has(key);
+				const existing = exists ? params.collection.get(key) : void 0;
+				write({
+					type: exists ? "update" : "insert",
+					value: existing ? {
+						...existing,
+						...object
+					} : object
+				});
+			};
+			const deleteObjectByKey = (key) => {
+				write({
+					type: "delete",
+					key
+				});
+				return true;
+			};
+			const fetchEditHistoryPage = (body) => ObjectTypesV2.getEditsHistory(client, client.ontologyRid, objectType, body, { preview: true });
+			const decodeEditProperties = (properties, primaryKey) => decodeEditObject({
+				...properties,
+				[primaryKeyProperty]: primaryKey
+			});
+			const decodeWatcherObject = (object, primaryKey) => decodeObject({
+				...object,
+				[primaryKeyProperty]: primaryKey
+			});
+			const applyDirectWatcherUpdates = async (updates) => {
+				const pendingMutations = /* @__PURE__ */ new Map();
+				for (const update of updates) {
+					if (update.type !== "object") continue;
+					const object = update.object;
+					const primaryKey = getWatcherObjectKey(object);
+					switch (update.state) {
+						case "ADDED_OR_UPDATED":
+							pendingMutations.set(primaryKey, {
+								type: "upsert",
+								object: decodeWatcherObject(object, primaryKey)
+							});
+							break;
+						case "REMOVED": pendingMutations.set(primaryKey, { type: "delete" });
+					}
+				}
+				let transactionStarted = false;
+				for (const [primaryKey, mutation] of pendingMutations) {
+					if (!transactionStarted) {
+						begin();
+						transactionStarted = true;
+					}
+					if (mutation.type === "delete") deleteObjectByKey(primaryKey);
+					else upsertObject(mutation.object);
+				}
+				const receipt = transactionStarted ? commit() : true;
+				if (receipt !== true) await receipt;
+			};
+			const switchToDirectWebsocketMode = (error) => {
+				if (!editHistoryUnavailable) {
+					const errorMessage = error instanceof Error ? error.message : error;
+					console.warn(`Edit history catch-up failed for ${objectType}; falling back to direct websocket updates.`, errorMessage);
+					editHistoryUnavailable = true;
+				}
+				if (pendingDirectWatcherUpdates.length > 0) {
+					const updates = pendingDirectWatcherUpdates;
+					pendingDirectWatcherUpdates = [];
+					applyDirectWatcherUpdates(updates).catch((applyError) => {
+						console.warn(`Failed to apply direct Foundry updates for ${objectType}.`, applyError);
+					});
+				}
+				refreshInBackground();
+			};
+			const catchUpFromEditHistory = async () => {
+				const nextEditHistoryCursor = cloneEditHistoryCursor(editHistoryCursor);
+				const pendingMutations = /* @__PURE__ */ new Map();
+				const newOperationIds = /* @__PURE__ */ new Set();
+				for await (const entry of fromPagination((pageSize, pageToken) => fetchEditHistoryPage({
+					filters: {
+						type: "timestampFilter",
+						startTime: nextEditHistoryCursor.timestamp
+					},
+					includeAllPreviousProperties: true,
+					pageSize,
+					pageToken,
+					sortOrder: "oldest_first"
+				}), (page) => page.nextPageToken, (page) => page.data, EDIT_HISTORY_PAGE_SIZE)) {
+					if (disposed) break;
+					if (!shouldProcessEditHistoryEntry(nextEditHistoryCursor, entry)) continue;
+					advanceEditHistoryCursor(nextEditHistoryCursor, entry);
+					newOperationIds.add(entry.operationId);
+					const primaryKey = getPrimaryKeyValue(entry.objectPrimaryKey, primaryKeyProperty, decodeEditObject);
+					switch (entry.edit.type) {
+						case "createEdit":
+						case "modifyEdit":
+							pendingMutations.set(primaryKey, {
+								type: "upsert",
+								object: decodeEditProperties(entry.edit.properties, primaryKey)
+							});
+							break;
+						case "deleteEdit": pendingMutations.set(primaryKey, { type: "delete" });
+					}
+				}
+				if (disposed) return;
+				const checkpointChanged = !editHistoryCursorsEqual(editHistoryCursor, nextEditHistoryCursor);
+				let transactionStarted = false;
+				const ensureTransaction = () => {
+					if (transactionStarted) return;
+					begin();
+					transactionStarted = true;
+				};
+				for (const [primaryKey, mutation] of pendingMutations) {
+					ensureTransaction();
+					if (mutation.type === "delete") deleteObjectByKey(primaryKey);
+					else upsertObject(mutation.object);
+				}
+				if (checkpointChanged && collectionMetadata) {
+					ensureTransaction();
+					collectionMetadata.set(EDIT_HISTORY_CURSOR_METADATA_KEY, serializeEditHistoryCursor(nextEditHistoryCursor));
+				}
+				const receipt = transactionStarted ? commit() : true;
+				if (checkpointChanged) editHistoryCursor = nextEditHistoryCursor;
+				if (newOperationIds.size > 0) seenOperationIds.setState((current) => /* @__PURE__ */ new Set([...current, ...newOperationIds]));
+				pendingDirectWatcherUpdates = [];
+				if (receipt !== true) await receipt;
+			};
+			const refreshAllFromSource = async () => {
+				const objects = await fetchFoundryObjects(client, objectType, selectedProperties, {}, decodeObject);
+				if (disposed) throw new ObjectCollectionSyncAbortedError(objectType);
+				begin();
+				truncate();
+				for (const object of objects) write({
+					type: "insert",
+					value: object
+				});
+				const receipt = commit();
+				if (receipt !== true) await receipt;
+				if (disposed) throw new ObjectCollectionSyncAbortedError(objectType);
+				while (pendingDirectWatcherUpdates.length > 0 && !disposed) {
+					const updates = pendingDirectWatcherUpdates;
+					pendingDirectWatcherUpdates = [];
+					await applyDirectWatcherUpdates(updates);
+				}
+				if (disposed) throw new ObjectCollectionSyncAbortedError(objectType);
+				fullSourceRefreshVersion.setState((version) => version + 1);
+			};
+			requestFullRefresh = () => {
+				fullRefreshRequested = true;
+				if (fullRefreshTask) return fullRefreshTask;
+				const priorCatchUp = catchUpTask;
+				fullRefreshTask = (async () => {
+					if (priorCatchUp) await priorCatchUp;
+					if (disposed) throw new ObjectCollectionSyncAbortedError(objectType);
+					while (fullRefreshRequested && !disposed) {
+						fullRefreshRequested = false;
+						await refreshAllFromSource();
+					}
+				})().catch(async (error) => {
+					while (pendingDirectWatcherUpdates.length > 0 && !disposed) {
+						const updates = pendingDirectWatcherUpdates;
+						pendingDirectWatcherUpdates = [];
+						try {
+							await applyDirectWatcherUpdates(updates);
+						} catch (applyError) {
+							console.warn(`Failed to apply queued Foundry updates for ${objectType}.`, applyError);
+							break;
+						}
+					}
+					throw error;
+				}).finally(() => {
+					fullRefreshTask = void 0;
+					if (fullRefreshRequested && !disposed) refreshInBackground();
+				});
+				return fullRefreshTask;
+			};
+			requestEditHistoryCatchUp = () => {
+				if (editHistoryUnavailable) return;
+				catchUpRequested = true;
+				if (catchUpTask) return;
+				const priorRefresh = fullRefreshTask;
+				catchUpTask = (async () => {
+					if (priorRefresh) await priorRefresh;
+					while (catchUpRequested && !disposed) {
+						catchUpRequested = false;
+						await catchUpFromEditHistory();
+					}
+				})().catch((error) => {
+					switchToDirectWebsocketMode(error);
+				}).finally(() => {
+					catchUpTask = void 0;
+					if (catchUpRequested && !disposed) requestEditHistoryCatchUp?.();
+				});
+			};
+			const loadSubset = async (opts) => {
+				const objects = await fetchFoundryObjects(client, objectType, selectedProperties, opts, decodeObject);
+				if (objects.length > 0) {
+					begin();
+					for (const object of objects) upsertObject(object);
+					const receipt = commit(opts.signal);
+					if (receipt !== true) await receipt;
+				}
+			};
+			const loadSubsetDedupe = new DeduplicatedLoadSubset({ loadSubset });
+			const unsubscribe = live ? getObjectSetWatcherManager(client).subscribe({
+				type: "base",
+				objectType
+			}, (message) => {
+				switch (message.type) {
+					case "change":
+						if (fullRefreshTask) pendingDirectWatcherUpdates.push(...message.updates);
+						else if (editHistoryUnavailable) applyDirectWatcherUpdates(message.updates).catch((error) => {
+							console.warn(`Failed to apply direct Foundry updates for ${objectType}.`, error);
+							refreshInBackground();
+						});
+						else {
+							pendingDirectWatcherUpdates.push(...message.updates);
+							requestEditHistoryCatchUp?.();
+						}
+						break;
+					case "refresh":
+						if (editHistoryUnavailable) refreshInBackground();
+						else requestEditHistoryCatchUp?.();
+						break;
+					case "state":
+						if (message.status !== "open") break;
+						if (editHistoryUnavailable) refreshInBackground();
+						else requestEditHistoryCatchUp?.();
+				}
+			}) : () => {};
+			if (initialCommit === true) markReady();
+			else initialCommit.then(markReady, markError);
+			return {
+				loadSubset: loadSubsetDedupe.loadSubset,
+				cleanup: () => {
+					disposed = true;
+					requestEditHistoryCatchUp = void 0;
+					requestFullRefresh = void 0;
+					syncDisposed.setState(() => true);
+					unsubscribe();
+					loadSubsetDedupe.reset();
+				}
+			};
+		} },
+		utils: {
+			awaitOperationId,
+			refresh
+		}
+	};
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function objectCollectionOptions(config) {
-    const { client, objectType, primaryKeyProperty, selectedProperties, live, decodeObject, decodeEditObject, schema, ...rest } = config;
-    const { sync, utils } = createSyncConfig(client, objectType, primaryKeyProperty, selectedProperties, decodeObject, decodeEditObject, live);
-    if (schema === undefined) {
-        return { syncMode: "on-demand", sync, utils };
-    }
-    return {
-        ...rest,
-        schema,
-        defaultIndexType: BasicIndex,
-        autoIndex: "eager",
-        syncMode: "on-demand",
-        getKey: (object) => object[primaryKeyProperty],
-        sync,
-        utils,
-    };
+function objectCollectionOptions(config) {
+	const { client, objectType, primaryKeyProperty, selectedProperties, live, decodeObject, decodeEditObject, schema, ...rest } = config;
+	const { sync, utils } = createSyncConfig(client, objectType, primaryKeyProperty, selectedProperties, decodeObject, decodeEditObject, live);
+	if (schema === void 0) return {
+		syncMode: "on-demand",
+		sync,
+		utils
+	};
+	return {
+		...rest,
+		schema,
+		defaultIndexType: BasicIndex,
+		autoIndex: "eager",
+		syncMode: "on-demand",
+		getKey: (object) => object[primaryKeyProperty],
+		sync,
+		utils
+	};
 }
+//#endregion
+export { objectCollectionOptions };
+
 //# sourceMappingURL=objectCollectionOptions.js.map