@dittolive/ditto 4.8.2 → 4.9.0-alpha.1

package/node/ditto.cjs.js

@@ -16,9 +16,8 @@ class KeepAlive {
     }
     /** @internal */
     retain(id) {
-        if (typeof this.countsByID[id] === 'undefined') {
+        if (typeof this.countsByID[id] === 'undefined')
             this.countsByID[id] = 0;
-        }
         this.countsByID[id] += 1;
         if (this.intervalID === null) {
             // Keep the process alive as long as there is at least one ID being
@@ -37,9 +36,8 @@ class KeepAlive {
             throw new Error(`Internal inconsistency, trying to release a keep-alive ID that hasn't been retained before or isn't tracked anymore: ${id}`);
         }
         this.countsByID[id] -= 1;
-        if (this.countsByID[id] === 0) {
+        if (this.countsByID[id] === 0)
             delete this.countsByID[id];
-        }
         if (Object.keys(this.countsByID).length === 0) {
             // Nothing is tracked anymore, it's safe to clear the interval
             // and let the process do what it wants.
@@ -88,7 +86,7 @@ class Observer {
      * method. Otherwise returns `false`.
      */
     get isStopped() {
-        return this.token !== undefined && this.observerManager.hasObserver(this.token);
+        return (this.token !== undefined && this.observerManager.hasObserver(this.token));
     }
     /**
      * Stops the observation. Calling this method multiple times has no effect.
@@ -108,6 +106,8 @@ class Observer {
 }
 Observer.finalizationRegistry = new FinalizationRegistry(Observer.finalize);
 
+const isWebBuild = false;
+
 //
 // Copyright © 2021 DittoLive Incorporated. All rights reserved.
 //
@@ -118,6 +118,8 @@ const privateToken$1 = Symbol('privateConstructorToken');
 /**
  * Represents a CRDT counter that can be upserted as part of a document or
  * assigned to a property during an update of a document.
+ *
+ * Not available in React Native environments.
  */
 class Counter {
     /** The value of the counter. */
@@ -156,6 +158,8 @@ class MutableCounter extends Counter {
      * {@link PendingCursorOperation.update | PendingCursorOperation.update()} and
      * {@link PendingIDSpecificOperation.update | PendingIDSpecificOperation.update()},
      * otherwise an exception is thrown.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     increment(amount) {
         const mutDoc = this.mutDoc;
@@ -170,12 +174,10 @@ class MutableCounter extends Counter {
     }
     /** @internal */
     constructor() {
-        if (arguments[0] === privateToken$1) {
+        if (arguments[0] === privateToken$1)
             super();
-        }
-        else {
+        else
             throw new Error(`MutableCounter constructor is for internal use only.`);
-        }
     }
 }
 
@@ -189,6 +191,8 @@ const privateToken = '@ditto.ff82dae89821c5ab822a8b539056bce4';
 /**
  * Represents a CRDT register that can be upserted as part of a document or
  * assigned to a property during an update of a document.
+ *
+ * Not available in React Native environments.
  */
 class Register {
     /** Returns the value of the register. */
@@ -203,7 +207,9 @@ class Register {
     }
     /** @internal */
     static '@ditto.create'(mutableDocument, path, value) {
-        const register = mutableDocument ? new MutableRegister(value, privateToken) : new Register(value);
+        const register = mutableDocument
+            ? new MutableRegister(value, privateToken)
+            : new Register(value);
         register['@ditto.mutableDocument'] = mutableDocument;
         register['@ditto.path'] = path;
         register['@ditto.value'] = value;
@@ -216,15 +222,24 @@ class Register {
  * updating a document.
  *
  * This class can't be instantiated directly, it's returned automatically for
- * any register property of a document within an update block via {@link MutableDocumentPath.register}.
+ * any register property of a document within an update block via
+ * {@link MutableDocumentPath.register}.
+ *
+ * Not available in React Native environments.
  */
 class MutableRegister extends Register {
-    /** Returns the value of the register. */
+    /**
+     * Returns the value of the register.
+     *
+     * Not available in React Native environments.
+     */
     get value() {
         return super.value;
     }
     /**
      * Convenience setter, equivalent to {@link set | set()}.
+     *
+     * Not available in React Native environments.
      */
     set value(value) {
         this.set(value);
@@ -236,6 +251,8 @@ class MutableRegister extends Register {
      * {@link PendingCursorOperation.update | PendingCursorOperation.update()} and
      * {@link PendingIDSpecificOperation.update | PendingIDSpecificOperation.update()},
      * otherwise an exception is thrown.
+     *
+     * Not available in React Native environments.
      */
     set(value) {
         const mutableDocument = this['@ditto.mutableDocument'];
@@ -247,12 +264,10 @@ class MutableRegister extends Register {
     }
     /** @internal */
     constructor(value) {
-        if (arguments[1] === privateToken) {
+        if (arguments[1] === privateToken)
             super(value);
-        }
-        else {
+        else
             throw new Error(`MutableRegister constructor is for internal use only.`);
-        }
     }
 }
 
@@ -295,6 +310,7 @@ function ditto_auth_client_is_web_valid(...args) { return ditto.ditto_auth_clien
 function ditto_auth_client_is_x509_valid(...args) { return ditto.ditto_auth_client_is_x509_valid(...args) }
 function ditto_auth_client_login_with_credentials(...args) { return ditto.ditto_auth_client_login_with_credentials(...args) }
 function ditto_auth_client_login_with_token(...args) { return ditto.ditto_auth_client_login_with_token(...args) }
+function ditto_auth_client_login_with_token_and_feedback(...args) { return ditto.ditto_auth_client_login_with_token_and_feedback(...args) }
 function ditto_auth_client_logout(...args) { return ditto.ditto_auth_client_logout(...args) }
 function ditto_auth_client_make_login_provider(...args) { return ditto.ditto_auth_client_make_login_provider(...args) }
 function ditto_auth_client_set_validity_listener(...args) { return ditto.ditto_auth_client_set_validity_listener(...args) }
@@ -438,8 +454,6 @@ function refCStringToString(...args) { return ditto.refCStringToString(...args)
 function setDeadlockTimeout$1(...args) { return ditto.setDeadlockTimeout(...args) }
 function withOutBoxCBytes(...args) { return ditto.withOutBoxCBytes(...args) }
 
-const isWebBuild = false;
-
 //
 // Copyright © 2023 DittoLive Incorporated. All rights reserved.
 //
@@ -557,44 +571,28 @@ var DittoCRDTType;
 // are currently only used by the Node Linux & Windows build. See comment
 // in `sync.ts` -> `Ditto.applyPeerToPeerBluetoothLE()` for details.
 function dittoAddInternalBLEClientTransport(ditto) {
-    {
-        return ditto_add_internal_ble_client_transport(ditto);
-    }
+    return ditto_add_internal_ble_client_transport(ditto);
 }
 function dittoAddInternalBLEServerTransport(ditto) {
-    {
-        return ditto_add_internal_ble_server_transport(ditto);
-    }
+    return ditto_add_internal_ble_server_transport(ditto);
 }
 function bleClientFreeHandle(handle) {
-    {
-        return ble_client_free_handle(handle);
-    }
+    return ble_client_free_handle(handle);
 }
 function bleServerFreeHandle(handle) {
-    {
-        return ble_server_free_handle(handle);
-    }
+    return ble_server_free_handle(handle);
 }
 function dittoAddInternalMdnsTransport(ditto) {
-    {
-        return ditto_add_internal_mdns_client_transport(ditto);
-    }
+    return ditto_add_internal_mdns_client_transport(ditto);
 }
 function mdnsClientFreeHandle(handle) {
-    {
-        return mdns_client_free_handle(handle);
-    }
+    return mdns_client_free_handle(handle);
 }
 function dittoAddInternalMdnsAdvertiser(ditto) {
-    {
-        return ditto_add_internal_mdns_server_transport(ditto);
-    }
+    return ditto_add_internal_mdns_server_transport(ditto);
 }
 function mdnsServerFreeHandle(handle) {
-    {
-        return mdns_server_free_handle(handle);
-    }
+    return mdns_server_free_handle(handle);
 }
 // ------------------------------------------------------------- Document ------
 /** @internal */
@@ -602,8 +600,10 @@ function documentSetCBORWithTimestamp(document, path, cbor, timestamp) {
     ensureInitialized();
     const pathX = bytesFromString(path);
     const errorCode = ditto_document_set_cbor_with_timestamp(document, pathX, cbor, timestamp);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_document_set_cbor_with_timestamp() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_document_set_cbor_with_timestamp() failed with error code: ${errorCode}`);
+    }
 }
 /** @internal */
 function documentSetCBOR(document, path, cbor) {
@@ -611,8 +611,10 @@ function documentSetCBOR(document, path, cbor) {
     // NOTE: not sure if this should be async or not.
     const pathX = bytesFromString(path);
     const errorCode = ditto_document_set_cbor(document, pathX, cbor);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_document_set_cbor() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_document_set_cbor() failed with error code: ${errorCode}`);
+    }
 }
 /** @internal */
 function documentID(self) {
@@ -637,16 +639,20 @@ function documentRemove(document, path) {
     ensureInitialized();
     const pathBytes = bytesFromString(path);
     const errorCode = ditto_document_remove(document, pathBytes);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_document_remove() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_document_remove() failed with error code: ${errorCode}`);
+    }
 }
 /** @internal */
 function documentIncrementCounter(document, path, amount) {
     ensureInitialized();
     const pathBytes = bytesFromString(path);
     const errorCode = ditto_document_increment_counter(document, pathBytes, amount);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_document_increment_counter() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_document_increment_counter() failed with error code: ${errorCode}`);
+    }
 }
 /** @internal */
 function documentFree(self) {
@@ -666,8 +672,10 @@ function validateDocumentID(docID) {
     ensureInitialized();
     const cborCBytes = withOutBoxCBytes((outCBOR) => {
         const errorCode = ditto_validate_document_id(docID, outCBOR);
-        if (errorCode !== 0)
-            throw new Error(errorMessage() || `ditto_validate_document_id() failed with error code: ${errorCode}`);
+        if (errorCode !== 0) {
+            throw new Error(errorMessage() ||
+                `ditto_validate_document_id() failed with error code: ${errorCode}`);
+        }
         return outCBOR;
     });
     return boxCBytesIntoBuffer(cborCBytes);
@@ -681,8 +689,10 @@ async function collectionGet(ditto, collectionName, documentID, readTransaction)
     const { status_code: errorCode, document } = await ditto_collection_get(ditto, collectionNameX, documentID, readTransaction);
     if (errorCode === NOT_FOUND_ERROR_CODE)
         return null;
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_collection_get() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_collection_get() failed with error code: ${errorCode}`);
+    }
     return document;
 }
 /** @internal */
@@ -708,8 +718,10 @@ async function collectionInsertValue(ditto, collectionName, doc_cbor, writeStrat
             throw new Error(`Unsupported write strategy '${writeStrategy}' provided.`);
     }
     const { status_code: errorCode, id } = await ditto_collection_insert_value(ditto, collectionNameX, doc_cbor, strategy, null, writeTransaction !== null && writeTransaction !== void 0 ? writeTransaction : null);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_collection_insert_value() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_collection_insert_value() failed with error code: ${errorCode}`);
+    }
     return boxCBytesIntoBuffer(id);
 }
 /** @internal */
@@ -718,8 +730,10 @@ async function collectionRemove(ditto, collectionName, writeTransaction, documen
     // REFACTOR: add proper error handling.
     const collectionNameX = bytesFromString(collectionName);
     const { status_code: errorCode, bool_value: didRemove } = await ditto_collection_remove(ditto, collectionNameX, writeTransaction, documentID);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_collection_remove() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_collection_remove() failed with error code: ${errorCode}`);
+    }
     return didRemove;
 }
 /** @internal */
@@ -728,8 +742,10 @@ async function collectionEvict(ditto, collectionName, writeTransaction, document
     // REFACTOR: add proper error handling.
     const collectionNameX = bytesFromString(collectionName);
     const { status_code: errorCode, bool_value: didEvict } = await ditto_collection_evict(ditto, collectionNameX, writeTransaction, documentID);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_collection_evict() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_collection_evict() failed with error code: ${errorCode}`);
+    }
     return didEvict;
 }
 /** @internal */
@@ -737,8 +753,10 @@ async function collectionUpdate(ditto, collectionName, writeTransaction, documen
     ensureInitialized();
     const collectionNameX = bytesFromString(collectionName);
     const errorCode = await ditto_collection_update(ditto, collectionNameX, writeTransaction, document);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_collection_update() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_collection_update() failed with error code: ${errorCode}`);
+    }
 }
 /** @internal */
 async function collectionUpdateMultiple(ditto, collectionName, writeTransaction, documents) {
@@ -746,8 +764,10 @@ async function collectionUpdateMultiple(ditto, collectionName, writeTransaction,
     const collectionNameX = bytesFromString(collectionName);
     const cDocuments = jsDocsToCDocs(documents);
     const errorCode = await ditto_collection_update_multiple(ditto, collectionNameX, writeTransaction, cDocuments);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_collection_update_multiple() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_collection_update_multiple() failed with error code: ${errorCode}`);
+    }
 }
 /** @internal */
 async function collectionExecQueryStr(ditto, collectionName, writeTransaction, query, queryArgsCBOR, orderBy, limit, offset) {
@@ -791,8 +811,10 @@ function addSubscription(ditto, collectionName, query, queryArgsCBOR, orderBy, l
     const collectionNameX = bytesFromString(collectionName);
     const queryX = bytesFromString(query);
     const statusCode = ditto_add_subscription(ditto, collectionNameX, queryX, queryArgsCBOR, orderBy, limit, offset);
-    if (statusCode !== 0)
-        throw new Error(errorMessage() || `ditto_add_subscription() failed with error code: ${statusCode}`);
+    if (statusCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_add_subscription() failed with error code: ${statusCode}`);
+    }
 }
 /** @internal */
 function removeSubscription(ditto, collectionName, query, queryArgsCBOR, orderBy, limit, offset) {
@@ -800,8 +822,10 @@ function removeSubscription(ditto, collectionName, query, queryArgsCBOR, orderBy
     const collectionNameX = bytesFromString(collectionName);
     const queryX = bytesFromString(query);
     const statusCode = ditto_remove_subscription(ditto, collectionNameX, queryX, queryArgsCBOR, orderBy, limit, offset);
-    if (statusCode !== 0)
-        throw new Error(errorMessage() || `ditto_remove_subscription() failed with error code: ${statusCode}`);
+    if (statusCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_remove_subscription() failed with error code: ${statusCode}`);
+    }
 }
 /** @internal */
 function tryAddSyncSubscription(dittoPointer, query, queryArgsCBOR) {
@@ -844,9 +868,8 @@ function queryResultItems(queryResultPointer) {
     ensureInitialized();
     const rv = [];
     const resultCount = dittoffi_query_result_item_count(queryResultPointer);
-    for (let i = 0; i < resultCount; i++) {
+    for (let i = 0; i < resultCount; i++)
         rv.push(dittoffi_query_result_item_at(queryResultPointer, i));
-    }
     return rv;
 }
 /**
@@ -906,8 +929,10 @@ onError) {
     // callback itself may not have completed. This is fine, since `signalNext()`
     // shall be the proper way to let the Rust core know the FFI call completed.
     const { status_code: errorCode, i64: id } = ditto_live_query_register_str_detached(ditto, collectionNameBuffer, queryBuffer, queryArgsCBOR, orderBy, limit, offset, wrapBackgroundCbForFFI(onError, eventHandler));
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `\`ditto_live_query_register_str()\` failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `\`ditto_live_query_register_str()\` failed with error code: ${errorCode}`);
+    }
     return id;
 }
 /** @internal */
@@ -928,8 +953,10 @@ function tryExperimentalRegisterChangeObserver(ditto, query, queryArgsCBOR, chan
 async function liveQueryStart(ditto, liveQueryID) {
     ensureInitialized();
     const errorCode = await ditto_live_query_start(ditto, liveQueryID);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `\`ditto_live_query_start()\` failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `\`ditto_live_query_start()\` failed with error code: ${errorCode}`);
+    }
 }
 /** @internal */
 function liveQueryStop(ditto, liveQueryID) {
@@ -949,8 +976,10 @@ async function liveQueryWebhookRegister(ditto, collectionName, query, orderBy, l
     const queryBuffer = bytesFromString(query);
     const urlBuffer = bytesFromString(url);
     const { status_code: errorCode, id } = await ditto_live_query_webhook_register_str(ditto, collectionNameBuffer, queryBuffer, orderBy, limit, offset, urlBuffer);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `\`ditto_live_query_webhook_register_str()\` failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `\`ditto_live_query_webhook_register_str()\` failed with error code: ${errorCode}`);
+    }
     return boxCBytesIntoBuffer(id);
 }
 /** @internal */
@@ -969,8 +998,10 @@ async function readTransaction(ditto) {
     ensureInitialized();
     // REFACTOR: add proper error handling.
     const { status_code: errorCode, txn: readTransaction } = await ditto_read_transaction(ditto);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `\`ditto_read_transaction()\` failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `\`ditto_read_transaction()\` failed with error code: ${errorCode}`);
+    }
     return readTransaction;
 }
 /** @internal */
@@ -985,23 +1016,29 @@ async function writeTransaction(ditto) {
     ensureInitialized();
     // REFACTOR: add proper error handling.
     const { status_code: errorCode, txn: writeTransaction } = await ditto_write_transaction(ditto, null);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_write_transaction() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_write_transaction() failed with error code: ${errorCode}`);
+    }
     return writeTransaction;
 }
 /** @internal */
 async function writeTransactionCommit(ditto, self) {
     ensureInitialized();
     const errorCode = await ditto_write_transaction_commit(ditto, self);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_write_transaction_commit() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_write_transaction_commit() failed with error code: ${errorCode}`);
+    }
 }
 /** @internal */
 async function writeTransactionRollback(ditto, transaction) {
     ensureInitialized();
     const errorCode = await ditto_write_transaction_rollback(ditto, transaction);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_write_transaction_rollback() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_write_transaction_rollback() failed with error code: ${errorCode}`);
+    }
 }
 // --------------------------------------------------------------- Logger ------
 /** @internal */
@@ -1094,8 +1131,10 @@ function dittoIdentityConfigMakeOnlinePlayground(appID, sharedToken, baseURL) {
     const sharedTokenX = bytesFromString(sharedToken);
     const baseURLX = bytesFromString(baseURL);
     const { status_code: errorCode, identity_config: identityConfig } = ditto_identity_config_make_online_playground(appIDX, sharedTokenX, baseURLX);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_identity_config_make_online_playground() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_identity_config_make_online_playground() failed with error code: ${errorCode}`);
+    }
     return identityConfig;
 }
 /** @internal */
@@ -1104,8 +1143,10 @@ function dittoIdentityConfigMakeOnlineWithAuthentication(appID, baseURL) {
     const appIDX = bytesFromString(appID);
     const baseURLX = bytesFromString(baseURL);
     const { status_code: errorCode, identity_config: identityConfig } = ditto_identity_config_make_online_with_authentication(appIDX, baseURLX);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_identity_config_make_online_with_authentication() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_identity_config_make_online_with_authentication() failed with error code: ${errorCode}`);
+    }
     return identityConfig;
 }
 /** @internal */
@@ -1114,8 +1155,10 @@ function dittoIdentityConfigMakeOfflinePlayground(appId, siteID) {
     const appIdX = bytesFromString(appId);
     const siteIDX = Number(siteID);
     const { status_code: errorCode, identity_config: identityConfig } = ditto_identity_config_make_offline_playground(appIdX, siteIDX);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_identity_config_make_offline_playground() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_identity_config_make_offline_playground() failed with error code: ${errorCode}`);
+    }
     return identityConfig;
 }
 /** @internal */
@@ -1125,8 +1168,10 @@ function dittoIdentityConfigMakeSharedKey(appId, sharedKey, siteID) {
     const sharedKeyX = bytesFromString(sharedKey);
     const siteIDX = Number(siteID);
     const { status_code: errorCode, identity_config: identityConfig } = ditto_identity_config_make_shared_key(appIdX, sharedKeyX, siteIDX);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_identity_config_make_shared_key() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_identity_config_make_shared_key() failed with error code: ${errorCode}`);
+    }
     return identityConfig;
 }
 /** @internal */
@@ -1134,8 +1179,10 @@ function dittoIdentityConfigMakeManual(configCBORBase64) {
     ensureInitialized();
     const configCBORBase64X = bytesFromString(configCBORBase64);
     const { status_code: errorCode, identity_config: identityConfig } = ditto_identity_config_make_manual_v0(configCBORBase64X);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_identity_config_make_manual_v0() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_identity_config_make_manual_v0() failed with error code: ${errorCode}`);
+    }
     return identityConfig;
 }
 /** @internal */
@@ -1163,13 +1210,34 @@ function dittoAuthClientIsX509Valid(ditto) {
     ensureInitialized();
     return ditto_auth_client_is_x509_valid(ditto) !== 0;
 }
+async function dittoAuthClientLoginWithTokenAndFeedback(ditto, token, provider) {
+    ensureInitialized();
+    const tokenBytes = bytesFromString(token);
+    const providerBytes = bytesFromString(provider);
+    const result = await ditto_auth_client_login_with_token_and_feedback(ditto, tokenBytes, providerBytes);
+    // Our `login_with_token_and_feedback()` API returns the `clientInfo` string
+    // even when authentication has failed, so this function does not throw an
+    // error when the status code is non-zero.
+    const error = result.status_code === 0
+        ? null
+        : new DittoFFIError(result.status_code, undefined, 'Ditto failed to authenticate.');
+    const clientInfo = result.c_string
+        ? boxCStringIntoString(result.c_string)
+        : null;
+    return {
+        error,
+        clientInfo,
+    };
+}
 async function dittoAuthClientLoginWithToken(ditto, token, provider) {
     ensureInitialized();
     const tokenBytes = bytesFromString(token);
     const providerBytes = bytesFromString(provider);
     const errorCode = await ditto_auth_client_login_with_token(ditto, tokenBytes, providerBytes);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `Ditto failed to authenticate (error code: ${errorCode}).`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `Ditto failed to authenticate (error code: ${errorCode}).`);
+    }
 }
 async function dittoAuthClientLoginWithUsernameAndPassword(ditto, username, password, provider) {
     ensureInitialized();
@@ -1177,14 +1245,17 @@ async function dittoAuthClientLoginWithUsernameAndPassword(ditto, username, pass
     const passwordBytes = bytesFromString(password);
     const providerBytes = bytesFromString(provider);
     const errorCode = await ditto_auth_client_login_with_credentials(ditto, usernameBytes, passwordBytes, providerBytes);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `Ditto failed to authenticate (error code: ${errorCode}).`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `Ditto failed to authenticate (error code: ${errorCode}).`);
+    }
 }
 async function dittoAuthClientLogout(ditto) {
     ensureInitialized();
     const errorCode = await ditto_auth_client_logout(ditto);
-    if (errorCode !== 0)
+    if (errorCode !== 0) {
         throw new Error(errorMessage() || `Ditto failed to logout (error code: ${errorCode}).`);
+    }
 }
 // ---------------------------------------------------------------- Ditto ------
 /** @internal */
@@ -1199,8 +1270,10 @@ async function dittoGetCollectionNames(self) {
     const result = await ditto_get_collection_names(self);
     const errorCode = result.status_code;
     const cStringVec = result.names;
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_get_collection_names() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_get_collection_names() failed with error code: ${errorCode}`);
+    }
     // WORKAROUND: cStringVecToStringArray() returns an `object` for the Wasm
     // variant, but it really is an array. We therefore force-cast here. Remove as
     // soon the exported function has proper type.
@@ -1361,7 +1434,8 @@ function dittoSmallPeerInfoSetMetadata(dittoPointer, metadata) {
         case 3:
             throw new Error(`Validation error, ${errorMessage() || `'${metadata}' is not a valid JSON object`}`);
         default:
-            throw new Error(errorMessage() || `Internal inconsistency, ditto_small_peer_info_set_metadata() returned an unknown error code: ${statusCode}`);
+            throw new Error(errorMessage() ||
+                `Internal inconsistency, ditto_small_peer_info_set_metadata() returned an unknown error code: ${statusCode}`);
     }
 }
 /** @internal */
@@ -1446,8 +1520,10 @@ onError) {
 function dittoCancelResolveAttachment(dittoPointer, id, cancelToken) {
     ensureInitialized();
     const errorCode = ditto_cancel_resolve_attachment(dittoPointer, id, cancelToken);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_cancel_resolve_attachment() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_cancel_resolve_attachment() failed with error code: ${errorCode}`);
+    }
 }
 /** @internal */
 function freeAttachmentHandle(attachmentHandlePointer) {
@@ -1528,15 +1604,19 @@ function dittoStopHTTPServer(dittoPointer) {
 async function dittoRunGarbageCollection(dittoPointer) {
     ensureInitialized();
     const statusCode = await ditto_run_garbage_collection(dittoPointer);
-    if (statusCode !== 0)
-        throw new Error(errorMessage() || `ditto_run_garbage_collection() failed with error code: ${statusCode}`);
+    if (statusCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_run_garbage_collection() failed with error code: ${statusCode}`);
+    }
 }
 /** @internal */
 async function dittoDisableSyncWithV3(dittoPointer) {
     ensureInitialized();
     const errorCode = await ditto_disable_sync_with_v3(dittoPointer);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_disable_sync_with_v3() failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_disable_sync_with_v3() failed with error code: ${errorCode}`);
+    }
 }
 function dittoSetStaticTCPClients(ditto, listOfServers) {
     ensureInitialized();
@@ -1557,8 +1637,10 @@ function dittoSetStaticWebsocketClients(ditto, listOfServers, routingHint) {
 function documentsHash(documents) {
     ensureInitialized();
     const { status_code: errorCode, u64: hash } = ditto_documents_hash(documents);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `\`ditto_documents_hash()\` failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `\`ditto_documents_hash()\` failed with error code: ${errorCode}`);
+    }
     // `hash` is of type `number | BigInt`, let's unify it to `BigInt` to keep it simple.
     return BigInt(hash);
 }
@@ -1566,8 +1648,10 @@ function documentsHash(documents) {
 function documentsHashMnemonic(documents) {
     ensureInitialized();
     const { status_code: errorCode, c_string } = ditto_documents_hash_mnemonic(documents);
-    if (errorCode !== 0)
-        throw new Error(errorMessage() || `\`ditto_documents_hash_mnemonic()\` failed with error code: ${errorCode}`);
+    if (errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `\`ditto_documents_hash_mnemonic()\` failed with error code: ${errorCode}`);
+    }
     return boxCStringIntoString(c_string);
 }
 // ------------------------------------------------------------- base64 --------
@@ -1582,7 +1666,7 @@ function base64encode(bytes, paddingMode) {
  */
 function tryBase64Decode(base64, paddingMode) {
     const base64BytesPointer = bytesFromString(base64);
-    const result = dittoffi_try_base64_decode(base64BytesPointer, paddingMode || null);
+    const result = dittoffi_try_base64_decode(base64BytesPointer, paddingMode);
     throwOnErrorResult(result.error, 'dittoffi_try_base64_decode');
     return boxCBytesIntoBuffer(result.success);
 }
@@ -1613,28 +1697,23 @@ onError) {
 function transportsInit() {
     ensureInitialized();
     const { output: wasInitialized, errorType } = withTransportsError(ditto_sdk_transports_init);
-    if (wasInitialized === false) {
+    if (wasInitialized === false)
         throw new Error(`Failed to initialize transports (${errorType} error)`);
-    }
 }
 /** @internal */
 function transportsBLEIsAvailable(ditto) {
     ensureInitialized();
-    {
-        return ditto_sdk_transports_ble_is_available(ditto);
-    }
+    return ditto_sdk_transports_ble_is_available(ditto);
 }
 /** @internal */
 function transportsBLECreate(ditto) {
     ensureInitialized();
     {
         const { output: blePointer, errorType } = withTransportsError(ditto_sdk_transports_ble_create, ditto);
-        if (blePointer != null) {
+        if (blePointer != null)
             log('Info', `Bluetooth transport created.`);
-        }
-        else {
+        else
             log('Error', `Can't create bluetooth transport (${errorType} error).`);
-        }
         return blePointer;
     }
 }
@@ -1655,21 +1734,17 @@ function transportsBLEDestroy(ble) {
 /** @internal */
 function transportsLANIsAvailable(ditto) {
     ensureInitialized();
-    {
-        return ditto_sdk_transports_lan_is_available(ditto);
-    }
+    return ditto_sdk_transports_lan_is_available(ditto);
 }
 /** @internal */
 function transportsLANCreate(ditto) {
     ensureInitialized();
     {
         const { output: lanPointer, errorType } = withTransportsError(ditto_sdk_transports_lan_create, ditto);
-        if (lanPointer != null) {
+        if (lanPointer != null)
             log('Info', `LAN transport created.`);
-        }
-        else {
+        else
             log('Error', `Can't create LAN transport (${errorType} error).`);
-        }
         return lanPointer;
     }
 }
@@ -1678,33 +1753,27 @@ function transportsLANDestroy(lan) {
     ensureInitialized();
     {
         const { output: wasDestroyed, errorType } = withTransportsError(ditto_sdk_transports_lan_destroy, lan);
-        if (wasDestroyed === true) {
+        if (wasDestroyed === true)
             log('Info', 'LAN transport disabled.');
-        }
-        else {
+        else
             log('Error', `LAN transport could not be disabled (${errorType} error).`);
-        }
         return wasDestroyed;
     }
 }
 /** @internal */
 function transportsAWDLIsAvailable(ditto) {
     ensureInitialized();
-    {
-        return ditto_sdk_transports_awdl_is_available(ditto);
-    }
+    return ditto_sdk_transports_awdl_is_available(ditto);
 }
 /** @internal */
 function transportsAWDLCreate(ditto) {
     ensureInitialized();
     {
         const { output: awdlPointer, errorType } = withTransportsError(ditto_sdk_transports_awdl_create, ditto);
-        if (awdlPointer != null) {
+        if (awdlPointer != null)
             log('Info', `AWDL transport created.`);
-        }
-        else {
+        else
             log('Error', `Can't create AWDL transport (${errorType} error).`);
-        }
         return awdlPointer;
     }
 }
@@ -1746,9 +1815,7 @@ function withTransportsError(ffiFunction, ...args) {
 // ---------------------------------------------------------------- Other ------
 /** @internal */
 let isInitialized = false;
-{
-    isInitialized = true;
-}
+isInitialized = true;
 /** @internal */
 function initSDKVersion(platform, language, semVer) {
     ensureInitialized();
@@ -1756,8 +1823,10 @@ function initSDKVersion(platform, language, semVer) {
     bytesFromString(language);
     const semVerCString = bytesFromString(semVer);
     const errorCode = ditto_init_sdk_version(platform, language, semVerCString);
-    if (typeof errorCode !== 'undefined' && errorCode !== 0)
-        throw new Error(errorMessage() || `ditto_init_sdk_version() failed with error code: ${errorCode}`);
+    if (typeof errorCode !== 'undefined' && errorCode !== 0) {
+        throw new Error(errorMessage() ||
+            `ditto_init_sdk_version() failed with error code: ${errorCode}`);
+    }
 }
 /** @internal */
 function tryVerifyLicense(license) {
@@ -1774,7 +1843,6 @@ function tryVerifyLicense(license) {
 /** @internal */
 const NOT_FOUND_ERROR_CODE = -30798;
 /** @internal */
-// prettier-ignore
 function wrapBackgroundCbForFFI(onError, cb) {
     const errorHandler = onError !== null && onError !== void 0 ? onError : ((err) => log('Error', `The registered callback failed with ${err}`));
     return (ret_sender, ...args) => {
@@ -1794,7 +1862,6 @@ function wrapBackgroundCbForFFI(onError, cb) {
     };
 }
 /** @internal */
-// prettier-ignore
 function wrapAsyncBackgroundCbForFFI(onError, cb) {
     const errorHandler = onError !== null && onError !== void 0 ? onError : ((err) => log('Error', `The registered callback failed with ${err}`));
     return async (ret_sender, ...args) => {
@@ -1819,8 +1886,9 @@ function bytesFromString(jsString) {
         return undefined;
     if (jsString === null)
         return null;
-    if (typeof jsString !== 'string')
+    if (typeof jsString !== 'string') {
         throw new Error(`Can't convert string to Uint8Array, not a string: ${jsString}`);
+    }
     const textEncoder = new TextEncoder();
     return textEncoder.encode(`${jsString}\0`);
 }
@@ -1869,6 +1937,11 @@ const ERROR_CODES = {
     // REFACTOR: May be replaced by `unsupported` in v5. Tracked in #12755.
     'sdk/unsupported': 'The feature is not supported by the current environment.',
     //
+    // Authentication errors
+    //
+    /** Error when authentication failed */
+    'authentication/failed-to-authenticate': 'Ditto failed to authenticate.',
+    //
     // IO errors
     //
     /** Error when a file or directory already exists */
@@ -1947,8 +2020,12 @@ const DEFAULT_STATUS_CODE_MAPPING = {
     // Activation errors
     //
     ActivationLicenseTokenExpired: ['activation/license-token-expired'],
-    ActivationLicenseTokenInvalid: ['activation/license-token-verification-failed'],
-    ActivationLicenseUnsupportedFutureVersion: ['activation/license-token-unsupported-future-version'],
+    ActivationLicenseTokenInvalid: [
+        'activation/license-token-verification-failed',
+    ],
+    ActivationLicenseUnsupportedFutureVersion: [
+        'activation/license-token-unsupported-future-version',
+    ],
     ActivationNotActivated: ['activation/not-activated'],
     //
     // Input/output errors
@@ -1960,7 +2037,10 @@ const DEFAULT_STATUS_CODE_MAPPING = {
     //
     // SDK-specific errors
     //
-    JsFloatingStoreOperation: ['internal', 'Internal inconsistency, an outstanding store operation was not awaited.'],
+    JsFloatingStoreOperation: [
+        'internal',
+        'Internal inconsistency, an outstanding store operation was not awaited.',
+    ],
     //
     // DQL errors
     //
@@ -2024,9 +2104,8 @@ class DittoError extends Error {
      * @throws {@link DittoError} `internal`: when supplied with an invalid error code
      */
     constructor(code, message, context = {}) {
-        if (ERROR_CODES[code] == null) {
+        if (ERROR_CODES[code] == null)
             throw new DittoError('internal', `Invalid error code: ${code}`);
-        }
         super(message || ERROR_CODES[code]);
         /**
          * Use the error code to identify a specific error programatically.
@@ -2063,7 +2142,7 @@ class DittoError extends Error {
         };
         const err = new DittoError(code, message, errorContext);
         if (ffiError.stack != null) {
-            // @ts-ignore
+            // @ts-expect-error assigning to a readonly property
             err.stack = ffiError.stack;
         }
         return err;
@@ -2092,9 +2171,8 @@ function mapFFIErrors(closure, statusCodeMapping, context) {
         return closure();
     }
     catch (error) {
-        if (error instanceof DittoFFIError) {
+        if (error instanceof DittoFFIError)
             throw translateFFIError(error, statusCodeMapping, context);
-        }
         throw error;
     }
 }
@@ -2121,9 +2199,8 @@ async function mapFFIErrorsAsync(closure, statusCodeMapping, context) {
         return await closure();
     }
     catch (error) {
-        if (error instanceof DittoFFIError) {
+        if (error instanceof DittoFFIError)
             throw translateFFIError(error, statusCodeMapping, context);
-        }
         throw error;
     }
 }
@@ -2133,11 +2210,13 @@ const translateFFIError = (ffiError, customStatusCodeMapping, context) => {
     // which can't be used as an index into an object.
     const statusCode = ffiError.code.toString();
     let code, message;
-    if (customStatusCodeMapping != null && customStatusCodeMapping[statusCode] != null) {
+    if (customStatusCodeMapping != null &&
+        customStatusCodeMapping[statusCode] != null) {
         [code, message] = customStatusCodeMapping[statusCode];
     }
     else {
-        [code, message] = (_a = DEFAULT_STATUS_CODE_MAPPING[statusCode]) !== null && _a !== void 0 ? _a : DEFAULT_STATUS_CODE_MAPPING.default;
+        [code, message] =
+            (_a = DEFAULT_STATUS_CODE_MAPPING[statusCode]) !== null && _a !== void 0 ? _a : DEFAULT_STATUS_CODE_MAPPING.default;
     }
     return DittoError.fromFFIError(ffiError, code, message, context);
 };
@@ -2182,21 +2261,18 @@ class AttachmentToken {
      */
     static validateTypedInput(jsObj) {
         const type = jsObj[DittoCRDTTypeKey];
-        if (type !== DittoCRDTType.attachment) {
+        if (type !== DittoCRDTType.attachment)
             throw new Error('Invalid attachment token');
-        }
         const id = jsObj['_id'];
-        if (!(id instanceof Uint8Array)) {
+        if (!(id instanceof Uint8Array))
             throw new Error('Invalid attachment token id');
-        }
         const len = jsObj['_len'];
         if ((typeof len !== 'number' && typeof len !== 'bigint') || len < 0) {
             throw new Error('Invalid attachment token length, must be a non-negative number or bigint');
         }
         const meta = jsObj['_meta'];
-        if (typeof meta !== 'object') {
+        if (typeof meta !== 'object')
             throw new Error('Invalid attachment token meta');
-        }
         return { id, len, meta };
     }
     /**
@@ -2211,11 +2287,13 @@ class AttachmentToken {
      */
     static validateUntypedInput(jsObj) {
         const idBase64 = jsObj['id'];
-        if (typeof idBase64 !== 'string') {
+        if (typeof idBase64 !== 'string')
             throw new Error('Invalid attachment token id');
-        }
         const id = mapFFIErrors(() => tryBase64Decode(idBase64, 'Unpadded'), {
-            Base64Invalid: ['store/attachment-token-invalid', 'Failed to decode attachment token id from base64 input'],
+            Base64Invalid: [
+                'store/attachment-token-invalid',
+                'Failed to decode attachment token id from base64 input',
+            ],
         }, {
             attachmentTokenID: idBase64,
         });
@@ -2224,16 +2302,15 @@ class AttachmentToken {
             throw new Error('Invalid attachment token length, must be a non-negative number or bigint');
         }
         const meta = jsObj['metadata'];
-        if (typeof meta !== 'object') {
+        if (typeof meta !== 'object')
             throw new Error('Invalid attachment token meta');
-        }
         return { id, len, meta };
     }
 }
 
 // NOTE: this is patched up with the actual build version by Jake task
 // build:package and has to be a valid semantic version as defined here: https://semver.org.
-const fullBuildVersionString = '4.8.2';
+const fullBuildVersionString = '4.9.0-alpha.1';
 
 //
 // Copyright © 2021 DittoLive Incorporated. All rights reserved.
@@ -2383,7 +2460,7 @@ class Logger {
      * callbacks.
      *
      * @throws {TypeError} if `callback` is not a function or `undefined`.
-     * @throws {Error} if called in a React Native environment.
+     * @throws {Error} when called in a React Native environment.
      */
     static async setCustomLogCallback(callback) {
         if (callback != null && typeof callback !== 'function') {
@@ -2446,10 +2523,10 @@ class Logger {
             throw new TypeError(`Expected parameter 'path' to be a string, but got ${typeof path}.`);
         }
         let normalizedPath = path;
-        if (process.platform === 'win32' && !path.startsWith('\\\\?\\')) {
-            if (path.length === 0) {
+        if (process.platform === 'win32' &&
+            !path.startsWith('\\\\?\\')) {
+            if (path.length === 0)
                 throw new DittoError('io/not-found', 'The path must not be empty.');
-            }
             // Normalize the path on Windows to prevent issues with long paths.
             // Windows has a hard limit of 260 characters for paths.
             // c.f. httpes://docs.microsoft.com/en-us/windows/win32/fileio/naming-a-file#maximum-path-length-limitation
@@ -3581,22 +3658,17 @@ class DocumentID {
     equals(documentID) {
         const left = this['@ditto.cbor'];
         const right = documentID['@ditto.cbor'];
-        if (left === right) {
+        if (left === right)
             return true;
-        }
-        if (!(left instanceof Uint8Array)) {
+        if (!(left instanceof Uint8Array))
             return false;
-        }
-        if (!(right instanceof Uint8Array)) {
+        if (!(right instanceof Uint8Array))
             return false;
-        }
-        if (left.length !== right.length) {
+        if (left.length !== right.length)
             return false;
-        }
-        for (let i = 0; i < left.length; i += 1) {
+        for (let i = 0; i < left.length; i += 1)
             if (left[i] !== right[i])
                 return false;
-        }
         return true;
     }
     /**
@@ -3640,9 +3712,8 @@ class DocumentID {
 // -----------------------------------------------------------------------------
 /** @internal */
 function validateDocumentIDValue(id) {
-    if (typeof id === 'undefined') {
+    if (typeof id === 'undefined')
         throw new Error(`Invalid document ID: ${id}`);
-    }
     return id;
 }
 /** @internal */
@@ -3713,15 +3784,12 @@ class Handle {
      */
     derefOrNull() {
         var _b;
-        if (this.isClosed) {
+        if (this.isClosed)
             return null;
-        }
-        if (this.isFinalized) {
+        if (this.isFinalized)
             return null;
-        }
-        if (this.isUnregistered) {
+        if (this.isUnregistered)
             return null;
-        }
         return (_b = this.pointer) !== null && _b !== void 0 ? _b : null;
     }
     /**
@@ -3853,9 +3921,8 @@ class Bridge {
      *
      * @internal */
     get type() {
-        if (this.internalType == null) {
+        if (this.internalType == null)
             throw new Error('Bridge type has not been registered yet.');
-        }
         return this.internalType;
     }
     /**
@@ -3908,8 +3975,9 @@ class Bridge {
         const handle = this.handlesByAddress[pointer.addr];
         if (!handle)
             return undefined;
-        if (handle.type !== this.type)
+        if (handle.type !== this.type) {
             throw new Error(`Can't return object for pointer, pointer is associated with an object of type ${handle.type} but this bridge is configured for ${this.type}`);
+        }
         // This throws an error if the object has been garbage collected but the
         // finalizer has not been called yet.
         return handle.object();
@@ -3928,9 +3996,8 @@ class Bridge {
      */
     bridge(pointer, objectOrCreate) {
         const existingObject = this.objectFor(pointer);
-        if (existingObject) {
+        if (existingObject)
             return existingObject;
-        }
         if (!objectOrCreate) {
             objectOrCreate = () => {
                 return Reflect.construct(this.type, []);
@@ -3961,17 +4028,21 @@ class Bridge {
      * @private */
     register(object, pointer) {
         const objectType = object.constructor;
-        if (objectType !== this.type)
+        if (objectType !== this.type) {
             throw new Error(`Can't register, bridge is configured for type ${this.type.name} but passed in object is of type ${objectType.name}`);
+        }
         const existingHandle = this.handlesByObject.get(object);
         const existingPointer = existingHandle ? existingHandle.pointer : null;
         // Check that both pointer and handle are undefined at this point.
-        if (existingPointer != null && existingHandle != null)
+        if (existingPointer != null && existingHandle != null) {
             throw new Error(`Can't register, an object for the passed in pointer has previously been registered: ${existingHandle.object()}`);
-        if (existingPointer != null && existingHandle == null)
+        }
+        if (existingPointer != null && existingHandle == null) {
             throw new Error(`Internal inconsistency, trying to register an object which has an associated pointer but no handle entry: ${objectType.name} at ${existingPointer.type} ${existingPointer.addr}`);
-        if (existingPointer == null && existingHandle != null)
+        }
+        if (existingPointer == null && existingHandle != null) {
             throw new Error(`Internal inconsistency, trying to register an object which has a handle entry but no associated pointer: ${objectType.name} ${object}`);
+        }
         const handle = new Handle(this, object, pointer);
         this.handlesByAddress[pointer.addr] = handle;
         this.handlesByObject.set(object, handle);
@@ -3991,21 +4062,28 @@ class Bridge {
     unregister(object) {
         const objectType = object.constructor;
         const bridgeType = this.type;
-        if (objectType !== bridgeType)
+        if (objectType !== bridgeType) {
             throw new Error(`Can't unregister, bridge is configured for type ${bridgeType.name} but passed in object is of type ${objectType.name}`);
+        }
         const handle = this.handlesByObject.get(object);
-        if (handle == null)
+        if (handle == null) {
             throw new Error(`Can't unregister, object has not been registered before: ${object}`);
-        if (handle.type !== bridgeType)
+        }
+        if (handle.type !== bridgeType) {
             throw new Error(`Internal inconsistency, trying to unregister an object that has a handle with a different type than that of the bridge: ${handle}`);
-        if (handle.objectOrNull() !== object)
+        }
+        if (handle.objectOrNull() !== object) {
             throw new Error(`Internal inconsistency, trying to unregister an object whose associated handle holds a different object: ${handle}`);
-        if (handle.isClosed)
+        }
+        if (handle.isClosed) {
             throw new Error(`Can't unregister, object has been closed before: ${object}`);
-        if (handle.isFinalized)
+        }
+        if (handle.isFinalized) {
             throw new Error(`Can't unregister, object has been finalized before: ${object}`);
-        if (handle.isUnregistered)
+        }
+        if (handle.isUnregistered) {
             throw new Error(`Can't unregister, object has been unregistered already: ${object}`);
+        }
         handle.bridgeWillUnregister();
         this.finalizationRegistry.unregister(object);
         delete this.handlesByAddress[handle.pointer.addr];
@@ -4022,9 +4100,8 @@ class Bridge {
         }
         for (const handle of Object.values(this.handlesByAddress)) {
             const object = handle.object();
-            if (object) {
+            if (object)
                 this.unregister(object);
-            }
         }
     }
     /**
@@ -4035,22 +4112,27 @@ class Bridge {
     async close(object) {
         const objectType = object.constructor;
         const bridgeType = this.type;
-        if (objectType !== bridgeType)
+        if (objectType !== bridgeType) {
             throw new Error(`Can't close, bridge is configured for type ${bridgeType.name} but passed in object is of type ${objectType.name}`);
+        }
         const handle = this.handlesByObject.get(object);
-        if (handle == null)
+        if (handle == null) {
             throw new Error(`Can't close an object that has not been registered before: ${object}`);
-        if (handle.type !== bridgeType)
+        }
+        if (handle.type !== bridgeType) {
             throw new Error(`Internal inconsistency, trying to close an object that has a handle with a different type than that of the bridge: ${handle}`);
+        }
         if (handle.isUnregistered)
             throw new Error(`Can't close object, object has been unregistered.`);
-        if (handle.isFinalized)
+        if (handle.isFinalized) {
             throw new Error(`Internal inconsistency, trying to close an object that has already been finalized.`);
+        }
         if (handle.isClosed)
             return;
         const pointer = handle.pointer;
-        if (!pointer)
+        if (!pointer) {
             throw new Error(`Internal inconsistency, trying to close an object whose pointer is null.`);
+        }
         handle.bridgeWillClose();
         delete this.handlesByAddress[pointer.addr];
         await this.release(pointer);
@@ -4064,15 +4146,18 @@ class Bridge {
         return Object.keys(this.handlesByAddress).length;
     }
     async finalize(handle) {
-        if (handle.isFinalized)
+        if (handle.isFinalized) {
             throw new Error(`Internal inconsistency, trying to finalize an object that has already been finalized.`);
-        if (handle.isUnregistered)
+        }
+        if (handle.isUnregistered) {
             throw new Error(`Internal inconsistency, trying to finalize an object that has been unregistered before.`);
+        }
         handle.bridgeWillFinalize();
         if (!handle.isClosed) {
             const pointer = handle.pointer;
-            if (!pointer)
+            if (!pointer) {
                 throw new Error(`Internal inconsistency, trying to finalize an object whose pointer is null.`);
+            }
             delete this.handlesByAddress[pointer.addr];
             await this.release(pointer);
         }
@@ -4229,9 +4314,8 @@ function augmentJSONValue(json, mutDoc, workingPath) {
             return new AttachmentToken(json);
         }
         else {
-            for (const [key, value] of Object.entries(json)) {
+            for (const [key, value] of Object.entries(json))
                 json[key] = augmentJSONValue(value, mutDoc, `${workingPath}['${key}']`);
-            }
             return json;
         }
     }
@@ -4281,9 +4365,8 @@ function desugarJSObject(jsObj) {
         else {
             // Create a copy to not mutate the original object
             const jsObjJSON = {};
-            for (const [key, value] of Object.entries(jsObj)) {
+            for (const [key, value] of Object.entries(jsObj))
                 jsObjJSON[key] = desugarJSObject(value);
-            }
             return jsObjJSON;
         }
     }
@@ -4304,9 +4387,8 @@ function desugarJSObject(jsObj) {
  * @throws {Error} If `jsObj` is a non-finite float value.
  */
 function checkForUnsupportedValues(jsObj) {
-    if (Number.isNaN(jsObj) || jsObj === Infinity || jsObj === -Infinity) {
+    if (Number.isNaN(jsObj) || jsObj === Infinity || jsObj === -Infinity)
         throw new Error('Non-finite float values are not supported');
-    }
 }
 
 //
@@ -4319,6 +4401,8 @@ function checkForUnsupportedValues(jsObj) {
  *   - `set`
  *   - `removed`
  *   - `incremented`
+ *
+ * Not available in React Native environments.
  */
 class UpdateResult {
     // ----------------------------------------------------------- Internal ------
@@ -4408,8 +4492,9 @@ function validateQuery(query, options = {}) {
     if (query === '')
         throw new Error(`${errorMessagePrefix} query is an empty string.`);
     const validatedQuery = query.trim();
-    if (validatedQuery === '')
+    if (validatedQuery === '') {
         throw new Error(`${errorMessagePrefix} query contains only whitespace characters.`);
+    }
     return validatedQuery;
 }
 // -------------------------------------------------------------- Helpers ------
@@ -4423,9 +4508,8 @@ function validateQuery(query, options = {}) {
  * See https://nodejs.org/api/util.html#custom-inspection-functions-on-objects
  */
 function customInspectRepresentation(documentLike, inspect) {
-    if (inspect === undefined) {
+    if (inspect === undefined)
         return `${documentLike.constructor.name} ${JSON.stringify({ value: documentLike.value }, null, 2)}`;
-    }
     return `${documentLike.constructor.name} ${inspect({ value: documentLike.value })}`;
 }
 // --------------------------------------------------------------- System ------
@@ -4482,9 +4566,8 @@ class KeyPath {
      * starts with a character or an underscore.
      */
     static withLeadingDot(keyPath) {
-        if (typeof keyPath === 'number') {
+        if (typeof keyPath === 'number')
             return keyPath;
-        }
         if (typeof keyPath !== 'string') {
             throw new Error(`Key-path must be a string or a number but is ${typeof keyPath}: ${keyPath}`);
         }
@@ -4495,9 +4578,8 @@ class KeyPath {
      * Returns the key-path by removing the leading dot if it starts with one.
      */
     static withoutLeadingDot(keyPath) {
-        if (typeof keyPath === 'number') {
+        if (typeof keyPath === 'number')
             return keyPath;
-        }
         if (typeof keyPath !== 'string') {
             throw new Error(`Key-path must be a string or a number but is ${typeof keyPath}: ${keyPath}`);
         }
@@ -4511,16 +4593,14 @@ class KeyPath {
     static validate(keyPath, options = {}) {
         var _a;
         const isInitial = (_a = options.isInitial) !== null && _a !== void 0 ? _a : false;
-        if (typeof keyPath === 'number') {
+        if (typeof keyPath === 'number')
             return Math.floor(Math.abs(keyPath));
-        }
         if (typeof keyPath !== 'string') {
             throw new Error(`Key-path must be a string or a number but is ${typeof keyPath}: ${keyPath}`);
         }
         const keyPathWithLeadingDot = this.withLeadingDot(keyPath);
-        if (!validKeyPathRegExp.test(keyPathWithLeadingDot)) {
+        if (!validKeyPathRegExp.test(keyPathWithLeadingDot))
             throw new Error(`Key-path is not valid: ${keyPath}`);
-        }
         return isInitial ? keyPath : keyPathWithLeadingDot;
     }
     /**
@@ -4544,7 +4624,11 @@ class KeyPath {
         };
         function advance(keyPath) {
             if (typeof keyPath === 'number') {
-                return { nextPathComponentRaw: keyPath, nextPathComponent: keyPath, remainingPath: '' };
+                return {
+                    nextPathComponentRaw: keyPath,
+                    nextPathComponent: keyPath,
+                    remainingPath: '',
+                };
             }
             if (typeof keyPath !== 'string') {
                 throw new Error(`Can't return value at given keyPath, expected keyPath to be a string or a number but got ${typeof keyPath}: ${keyPath}`);
@@ -4592,12 +4676,11 @@ class KeyPath {
             const { nextPathComponentRaw, nextPathComponent, remainingPath } = advance(keyPath);
             evaluationResult.nextPathComponent = nextPathComponent;
             evaluationResult.remainingPath = remainingPath;
-            if (evaluationResult.coveredPath === null || typeof nextPathComponentRaw === 'number') {
+            if (evaluationResult.coveredPath === null ||
+                typeof nextPathComponentRaw === 'number')
                 evaluationResult.coveredPath = nextPathComponentRaw;
-            }
-            else {
+            else
                 evaluationResult.coveredPath += nextPathComponentRaw;
-            }
             if (remainingPath === '' && stopAtLastContainer) {
                 evaluationResult.value = object;
                 return evaluationResult;
@@ -4623,6 +4706,8 @@ class KeyPath {
  * type. You don't create a `DocumentPath` directly but obtain one via the
  * {@link Document.path | path} property or the {@link Document.at | at()}
  * method of {@link Document}.
+ *
+ * Not available in React Native environments.
  */
 class DocumentPath {
     /**
@@ -4643,6 +4728,8 @@ class DocumentPath {
      *    - `documentPath.at('passengers[2]')`
      *    - `documentPath.at('passengers[2].belongings[1].kind')`
      *    - `documentPath.at('.mileage')`
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     at(keyPathOrIndex) {
         if (typeof keyPathOrIndex === 'string') {
@@ -4654,7 +4741,11 @@ class DocumentPath {
         }
         if (typeof keyPathOrIndex === 'number') {
             const index = keyPathOrIndex;
-            const validatedIndex = validateNumber(index, { integer: true, min: 0, errorMessagePrefix: 'DocumentPath.at() validation failed index:' });
+            const validatedIndex = validateNumber(index, {
+                integer: true,
+                min: 0,
+                errorMessagePrefix: 'DocumentPath.at() validation failed index:',
+            });
             return new DocumentPath(this.document, `${this.path}[${validatedIndex.toString()}]`, false);
         }
         throw new Error(`Can't return document path at key-path or index, string or number expected but got ${typeof keyPathOrIndex}: ${keyPathOrIndex}`);
@@ -4662,6 +4753,8 @@ class DocumentPath {
     /**
      * Traverses the document with the key-path represented by the receiver and
      * returns the corresponding object or value.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     get value() {
         return this.underlyingValueForPathType('Any');
@@ -4669,26 +4762,38 @@ class DocumentPath {
     /**
      * Returns the value at the previously specified key in the document as a
      * {@link Counter} if possible, otherwise returns `null`.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     get counter() {
         const underlyingValue = this.underlyingValueForPathType('Counter');
-        return typeof underlyingValue !== 'undefined' ? Counter['@ditto.create'](null, this.path, underlyingValue) : null;
+        return typeof underlyingValue !== 'undefined'
+            ? Counter['@ditto.create'](null, this.path, underlyingValue)
+            : null;
     }
     /**
      * Returns the value at the previously specified key in the document as a
      * {@link Register} if possible, otherwise returns `null`.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     get register() {
         const underlyingValue = this.underlyingValueForPathType('Register');
-        return typeof underlyingValue !== 'undefined' ? Register['@ditto.create'](null, this.path, underlyingValue) : null;
+        return typeof underlyingValue !== 'undefined'
+            ? Register['@ditto.create'](null, this.path, underlyingValue)
+            : null;
     }
     /**
      * Returns the value at the previously specified key in the document as an
      * {@link AttachmentToken} if possible, otherwise returns `null`.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     get attachmentToken() {
         const underlyingValue = this.underlyingValueForPathType('Attachment');
-        return typeof underlyingValue !== 'undefined' ? new AttachmentToken(underlyingValue) : null;
+        return typeof underlyingValue !== 'undefined'
+            ? new AttachmentToken(underlyingValue)
+            : null;
     }
     /** @internal */
     constructor(document, path, validate) {
@@ -4701,7 +4806,9 @@ class DocumentPath {
         const document = this.document;
         const documentHandle = Bridge.document.handleFor(document);
         const cborPathResult = documentGetCBORWithPathType(documentHandle.deref(), path, pathType);
-        return cborPathResult.cbor !== null ? CBOR.decode(cborPathResult.cbor) : undefined;
+        return cborPathResult.cbor !== null
+            ? CBOR.decode(cborPathResult.cbor)
+            : undefined;
     }
 }
 // -----------------------------------------------------------------------------
@@ -4710,6 +4817,8 @@ class DocumentPath {
  * a specific key-path. You don't create a `MutableDocumentPath` directly but
  * obtain one via the {@link MutableDocument.path | path} property or the
  * {@link MutableDocument.at | at()} method of {@link MutableDocument}.
+ *
+ * Not available in React Native environments.
  */
 class MutableDocumentPath {
     /**
@@ -4730,6 +4839,8 @@ class MutableDocumentPath {
      *    - `mutableDocumentPath.at('passengers[2]')`
      *    - `mutableDocumentPath.at('passengers[2].belongings[1].kind')`
      *    - `mutableDocumentPath.at('.mileage')`
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     at(keyPathOrIndex) {
         if (typeof keyPathOrIndex === 'string') {
@@ -4741,7 +4852,11 @@ class MutableDocumentPath {
         }
         if (typeof keyPathOrIndex === 'number') {
             const index = keyPathOrIndex;
-            const validatedIndex = validateNumber(index, { integer: true, min: 0, errorMessagePrefix: 'MutableDocumentPath.at() validation failed index:' });
+            const validatedIndex = validateNumber(index, {
+                integer: true,
+                min: 0,
+                errorMessagePrefix: 'MutableDocumentPath.at() validation failed index:',
+            });
             return new MutableDocumentPath(this.mutableDocument, `${this.path}[${validatedIndex.toString()}]`, false);
         }
         throw new Error(`Can't return mutable document path at key-path or index, string or number expected but got ${typeof keyPathOrIndex}: ${keyPathOrIndex}`);
@@ -4749,6 +4864,8 @@ class MutableDocumentPath {
     /**
      * Traverses the document with the key-path represented by the receiver and
      * returns the corresponding object or value.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     get value() {
         return this.underlyingValueForPathType('Any');
@@ -4756,26 +4873,38 @@ class MutableDocumentPath {
     /**
      * Returns the value at the previously specified key in the document as a
      * {@link MutableCounter} if possible, otherwise returns `null`.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     get counter() {
         const underlyingValue = this.underlyingValueForPathType('Counter');
-        return typeof underlyingValue !== 'undefined' ? Counter['@ditto.create'](this.mutableDocument, this.path, underlyingValue) : null;
+        return typeof underlyingValue !== 'undefined'
+            ? Counter['@ditto.create'](this.mutableDocument, this.path, underlyingValue)
+            : null;
     }
     /**
      * Returns the value at the previously specified key in the document as a
      * {@link MutableRegister} if possible, otherwise returns `null`.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     get register() {
         const underlyingValue = this.underlyingValueForPathType('Register');
-        return typeof underlyingValue !== 'undefined' ? Register['@ditto.create'](this.mutableDocument, this.path, underlyingValue) : null;
+        return typeof underlyingValue !== 'undefined'
+            ? Register['@ditto.create'](this.mutableDocument, this.path, underlyingValue)
+            : null;
     }
     /**
      * Returns the value at the previously specified key in the document as a
      * {@link AttachmentToken} if possible, otherwise returns `null`.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     get attachmentToken() {
         const underlyingValue = this.underlyingValueForPathType('Attachment');
-        return typeof underlyingValue !== 'undefined' ? new AttachmentToken(underlyingValue) : null;
+        return typeof underlyingValue !== 'undefined'
+            ? new AttachmentToken(underlyingValue)
+            : null;
     }
     /**
      * Sets a value at the document's key-path defined by the receiver.
@@ -4784,12 +4913,16 @@ class MutableDocumentPath {
      * default value. Set this to `true` if you want to set a default value that
      * you expect to be overwritten by other devices in the network. The default
      * value is `false`.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     set(value, isDefault) {
         return this['@ditto.set'](value, isDefault);
     }
     /**
      * Removes a value at the document's key-path defined by the receiver.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     remove() {
         return this['@ditto.remove']();
@@ -4805,7 +4938,9 @@ class MutableDocumentPath {
         const document = this.mutableDocument;
         const documentHandle = Bridge.mutableDocument.handleFor(document);
         const cborPathResult = documentGetCBORWithPathType(documentHandle.deref(), path, pathType);
-        return cborPathResult.cbor !== null ? CBOR.decode(cborPathResult.cbor) : undefined;
+        return cborPathResult.cbor !== null
+            ? CBOR.decode(cborPathResult.cbor)
+            : undefined;
     }
     /** @internal */
     '@ditto.increment'(amount) {
@@ -4842,12 +4977,10 @@ class MutableDocumentPath {
         const documentHandle = Bridge.mutableDocument.handleFor(this.mutableDocument);
         documentRemove(documentHandle.deref(), this.path);
         this.updateInMemory((container, lastPathComponent) => {
-            if (Array.isArray(container) && typeof lastPathComponent === 'number') {
+            if (Array.isArray(container) && typeof lastPathComponent === 'number')
                 container.splice(lastPathComponent, 1);
-            }
-            else {
+            else
                 delete container[lastPathComponent];
-            }
         });
         const updateResult = UpdateResult.removed(this.mutableDocument.id, this.path);
         this.recordUpdateResult(updateResult);
@@ -4855,7 +4988,9 @@ class MutableDocumentPath {
     /** @private */
     updateInMemory(block) {
         const mutableDocumentValue = this.mutableDocument.value;
-        const evaluationResult = KeyPath.evaluate(this.path, mutableDocumentValue, { stopAtLastContainer: true });
+        const evaluationResult = KeyPath.evaluate(this.path, mutableDocumentValue, {
+            stopAtLastContainer: true,
+        });
         block(evaluationResult.value, evaluationResult.nextPathComponent);
     }
     /** @private */
@@ -4876,10 +5011,16 @@ class MutableDocumentPath {
 // the object is inspected with console.log() or util.inspect().
 const CUSTOM_INSPECT_SYMBOL$1 = Symbol.for('nodejs.util.inspect.custom');
 // -----------------------------------------------------------------------------
-/** A document belonging to a {@link Collection} with an inner value. */
+/**
+ * A document belonging to a {@link Collection} with an inner value.
+ *
+ * Not available in React Native environments.
+ */
 class Document {
     /**
      * Returns a hash that represents the passed in document(s).
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     static hash(documentOrMany) {
         const documents = documentsFrom(documentOrMany);
@@ -4889,6 +5030,8 @@ class Document {
     /**
      * Returns a pattern of words that together create a mnemonic, which
      * represents the passed in document(s).
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     static hashMnemonic(documentOrMany) {
         const documents = documentsFrom(documentOrMany);
@@ -4897,6 +5040,8 @@ class Document {
     }
     /**
      * Returns the document ID.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     get id() {
         let id = this['@ditto.id'];
@@ -4910,6 +5055,8 @@ class Document {
     }
     /**
      * Returns the document path at the root of the document.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     get path() {
         return new DocumentPath(this, '', false);
@@ -4918,6 +5065,8 @@ class Document {
      * Convenience property, same as calling `path.value`. The value is cached on
      * first access and returned on subsequent calls without calling `path.value`
      * again.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     get value() {
         let value = this['@ditto.value'];
@@ -4929,6 +5078,8 @@ class Document {
     }
     /**
      * Convenience method, same as calling `path.at()`.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     at(keyPathOrIndex) {
         return this.path.at(keyPathOrIndex);
@@ -4978,10 +5129,14 @@ class Document {
  * `MutableDocument` directly but rather through the `update()` methods of
  * {@link PendingCursorOperation.update | PendingCursorOperation} and
  * {@link PendingIDSpecificOperation.update | PendingIDSpecificOperation}.
+ *
+ * Not available in React Native environments.
  */
 class MutableDocument {
     /**
      * Returns the ID of the document.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     get id() {
         let id = this['@ditto.id'];
@@ -4995,18 +5150,24 @@ class MutableDocument {
     }
     /**
      * Returns the document path at the root of the document.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     get path() {
         return new MutableDocumentPath(this, '', false);
     }
     /**
      * Convenience property, same as `path.value`.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     get value() {
         return this.path.value;
     }
     /**
      * Convenience method, same as calling `path.at()`.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     at(keyPathOrIndex) {
         return this.path.at(keyPathOrIndex);
@@ -5042,15 +5203,12 @@ MutableDocument.isIDCBORCanonical = Document.isIDCBORCanonical;
 // -----------------------------------------------------------------------------
 /** @private */
 function documentsFrom(documentOrMany) {
-    if (!documentOrMany) {
+    if (!documentOrMany)
         return [];
-    }
-    if (documentOrMany instanceof Document) {
+    if (documentOrMany instanceof Document)
         return [documentOrMany];
-    }
-    if (documentOrMany instanceof Array) {
+    if (documentOrMany instanceof Array)
         return documentOrMany;
-    }
     throw new Error(`Expected null, a single document, or an array of documents but got value of type ${typeof documentOrMany}: ${documentOrMany}`);
 }
 
@@ -5062,6 +5220,8 @@ function documentsFrom(documentOrMany) {
  * {@link UpdateResult | update results}. This is the data structure you get
  * when {@link PendingCursorOperation.update | updating} a set of documents
  * with detailed info about the performed updates.
+ *
+ * Not available in React Native environments.
  */
 class UpdateResultsMap {
     /**
@@ -5069,7 +5229,9 @@ class UpdateResultsMap {
      * the `documentID` or undefined if not found.
      */
     get(documentIDOrValue) {
-        const documentID = documentIDOrValue instanceof DocumentID ? documentIDOrValue : new DocumentID(documentIDOrValue);
+        const documentID = documentIDOrValue instanceof DocumentID
+            ? documentIDOrValue
+            : new DocumentID(documentIDOrValue);
         const documentIDString = documentID.toString();
         return this.updateResultsByDocumentIDString[documentIDString];
     }
@@ -5094,18 +5256,25 @@ class UpdateResultsMap {
             .map((documentID) => documentID.toString())
             .sort()
             .join(', ');
-        const updateResultsKeys = Object.keys(updateResultsByDocumentIDString).sort().join(', ');
+        const updateResultsKeys = Object.keys(updateResultsByDocumentIDString)
+            .sort()
+            .join(', ');
         if (documentIDStrings !== updateResultsKeys) {
             throw new Error("Internal inconsistency, can't construct update results map, documentIDs must all be keys in update results (by document ID string)");
         }
         this.documentIDs = documentIDs.slice();
-        this.updateResultsByDocumentIDString = { ...updateResultsByDocumentIDString };
+        this.updateResultsByDocumentIDString = {
+            ...updateResultsByDocumentIDString,
+        };
     }
 }
 
 //
 // Copyright © 2023 DittoLive Incorporated. All rights reserved.
 //
+/**
+ * Not available in React Native environments.
+ */
 class BasePendingCursorOperation {
     /**
      * Sorts the documents that match the query provided in the preceding
@@ -5119,6 +5288,7 @@ class BasePendingCursorOperation {
      * @param direction Specify whether you want the sorting order to be
      * `ascending` or `descending`. Defaults to `ascending`.
      *
+     * @throws {Error} when called in a React Native environment.
      * @return A cursor that you can chain further function calls and then either
      * get the matching documents immediately or get updates about them over time.
      */
@@ -5141,6 +5311,7 @@ class BasePendingCursorOperation {
      * @param offset The number of matching documents that you want the eventual
      * resulting set of matching documents to be offset by (and thus not include).
      *
+     * @throws {Error} when called in a React Native environment.
      * @return A cursor that you can chain further function calls and then either
      * get the matching documents immediately or get updates about them over time.
      */
@@ -5148,13 +5319,16 @@ class BasePendingCursorOperation {
         // REFACTOR: factor out parameter validation.
         if (offset < 0)
             throw new Error(`Can't offset by '${offset}', offset must be >= 0`);
-        if (!Number.isFinite(offset))
+        if (!Number.isFinite(offset)) {
             throw new Error(`Can't offset by '${offset}', offset must be a finite number`);
-        if (Number.isNaN(offset))
+        }
+        if (Number.isNaN(offset)) {
             throw new Error(`Can't offset by '${offset}', offset must be a valid number`);
+        }
         const integerOffset = Math.round(offset);
-        if (offset !== integerOffset)
+        if (offset !== integerOffset) {
             throw new Error(`Can't offset by '${offset}', offset must be an integer number`);
+        }
         this.currentOffset = offset;
         return this;
     }
@@ -5164,20 +5338,25 @@ class BasePendingCursorOperation {
      *
      * @param limit The maximum number of documents that will be returned.
      *
+     * @throws {Error} when called in a React Native environment.
      * @return A cursor that you can chain further function calls and then either
      * get the matching documents immediately or get updates about them over time.
      */
     limit(limit) {
         // REFACTOR: factor out parameter validation.
-        if (limit < -1)
+        if (limit < -1) {
             throw new Error(`Can't limit to '${limit}', limit must be >= -1 (where -1 means unlimited)`);
-        if (!Number.isFinite(limit))
+        }
+        if (!Number.isFinite(limit)) {
             throw new Error(`Can't limit to '${limit}', limit must be a finite number`);
-        if (Number.isNaN(limit))
+        }
+        if (Number.isNaN(limit)) {
             throw new Error(`Can't limit to '${limit}', limit must be a valid number`);
+        }
         const integerLimit = Math.round(limit);
-        if (limit !== integerLimit)
+        if (limit !== integerLimit) {
             throw new Error(`Can't limit to '${limit}', limit must be an integer number`);
+        }
         this.currentLimit = limit;
         return this;
     }
@@ -5185,6 +5364,7 @@ class BasePendingCursorOperation {
      * Executes the query generated by the preceding function chaining and return
      * the list of matching documents.
      *
+     * @throws {Error} when called in a React Native environment.
      * @returns An array promise containing {@link Document | documents} matching
      * the query generated by the preceding function chaining.
      */
@@ -5206,25 +5386,33 @@ class BasePendingCursorOperation {
      * chaining.
      *
      * @param closure A closure that gets called with all of the documents
-     * matching the query. The documents are instances of {@link MutableDocument}
-     * so you can call update-related functions on them.
-     * @param writeTransactionX  a transaction to perform the operation in.
+     *   matching the query. The documents are instances of
+     *   {@link MutableDocument} so you can call update-related functions on them.
+     * @param publicAPIName the name of the public API function that was called
+     *   to perform the operation. Used in error messages and warnings.
+     * @param writeTransactionPointer a transaction to perform the operation in.
+     *   If not provided, a new transaction will be created.
      *
      * @returns An {@link UpdateResultsMap} promise mapping document IDs to lists
-     * of {@link UpdateResult | update results} that describe the updates that
-     * were performed for each document.
+     *   of {@link UpdateResult | update results} that describe the updates that
+     *   were performed for each document.
+     *
      * @internal
      */
-    async updateWithTransaction(closure, writeTransactionX) {
+    async updateWithClosure(closure, publicAPIName, writeTransactionPointer) {
         const ditto = this.collection.store.ditto;
         return ditto.deferCloseAsync(async (dittoHandle) => {
             return await performAsyncToWorkaroundNonAsyncFFIAPI(async () => {
                 const query = this.query;
-                const documentsX = await collectionExecQueryStr(dittoHandle.deref(), this.collection.name, writeTransactionX, query, this.queryArgsCBOR, this.orderBys, this.currentLimit, this.currentOffset);
+                const transactionPointer = writeTransactionPointer !== null && writeTransactionPointer !== void 0 ? writeTransactionPointer : (await writeTransaction(dittoHandle.deref()));
+                const documentsX = await collectionExecQueryStr(dittoHandle.deref(), this.collection.name, transactionPointer, query, this.queryArgsCBOR, this.orderBys, this.currentLimit, this.currentOffset);
                 const mutableDocuments = documentsX.map((documentX) => {
                     return Bridge.mutableDocument.bridge(documentX, () => new MutableDocument());
                 });
-                closure(mutableDocuments);
+                if (closure(mutableDocuments) instanceof Promise) {
+                    Logger.warning(`Expected ${publicAPIName} to be called with a synchronous closure but ` +
+                        'it was called with an async closure.');
+                }
                 const updateResultsDocumentIDs = [];
                 const updateResultsByDocumentIDString = {};
                 for (const mutableDocument of mutableDocuments) {
@@ -5246,7 +5434,10 @@ class BasePendingCursorOperation {
                 }
                 // NOTE: ownership of documentsX (and contained documents)
                 // is transferred to Rust at this point.
-                await collectionUpdateMultiple(dittoHandle.deref(), this.collection.name, writeTransactionX, documentsX);
+                await collectionUpdateMultiple(dittoHandle.deref(), this.collection.name, transactionPointer, documentsX);
+                if (!writeTransactionPointer) {
+                    await writeTransactionCommit(dittoHandle.deref(), transactionPointer);
+                }
                 return new UpdateResultsMap(updateResultsDocumentIDs, updateResultsByDocumentIDString);
             });
         });
@@ -5288,11 +5479,14 @@ class BasePendingCursorOperation {
  * return value, or chain calls to update, evict or remove the document.
  *
  * Live queries and subscriptions are only available outside of a transaction.
+ *
+ * Not available in React Native environments.
  */
 class BasePendingIDSpecificOperation {
     /**
      * Executes the find operation to return the document with the matching ID.
      *
+     * @throws {Error} when called in a React Native environment.
      * @returns The {@link Document} promise with the ID provided in the
      * {@link Collection.findByID | findByID()} call or `undefined` if the document was
      * not found.
@@ -5326,6 +5520,64 @@ class BasePendingIDSpecificOperation {
     get query() {
         return `_id == ${this.documentID.toQueryCompatibleString()}`;
     }
+    /**
+     * Commit changes made by the given closure to the current document.
+     *
+     * @param closure
+     * @param throwOnAsyncClosure if true, throw an error when passed an async
+     *   closure, otherwise log a warning
+     * @param throwOnDocumentNotFound if true, throw an error if the document is
+     *   not found, otherwise call the closure with `undefined` and return an
+     *   empty array
+     * @param publicAPIName the name of the public API that was called, used in
+     *   error messages and warnings
+     * @param transaction the transaction to use, if not provided a new one will
+     *   be created and committed
+     * @internal
+     */
+    async updateWithClosure(closure, throwOnAsyncClosure, throwOnDocumentNotFound, publicAPIName, transaction) {
+        const ditto = this.collection.store.ditto;
+        return ditto.deferCloseAsync(async (dittoHandle) => {
+            var _a;
+            const readTransactionPointer = await readTransaction(dittoHandle.deref());
+            let documentPointer = null;
+            try {
+                documentPointer = await collectionGet(dittoHandle.deref(), this.collection.name, this.documentIDCBOR, readTransactionPointer);
+            }
+            finally {
+                readTransactionFree(readTransactionPointer);
+            }
+            const errorMessageAsyncClosure = `Expected ${publicAPIName} to be called with a synchronous ` +
+                'closure but it was called with an async closure';
+            if (!documentPointer) {
+                if (throwOnDocumentNotFound) {
+                    throw new Error(`Can't update, document with ID '${this.documentID.toString()}' not found in collection named '${this.collection.name}'`);
+                }
+                if (closure() instanceof Promise) {
+                    if (throwOnAsyncClosure)
+                        throw new TypeError(errorMessageAsyncClosure);
+                    else
+                        Logger.warning(errorMessageAsyncClosure);
+                }
+                return [];
+            }
+            const mutableDocument = Bridge.mutableDocument.bridge(documentPointer, () => new MutableDocument());
+            if (closure(mutableDocument) instanceof Promise) {
+                if (throwOnAsyncClosure)
+                    throw new TypeError(errorMessageAsyncClosure);
+                Logger.warning(errorMessageAsyncClosure);
+            }
+            const writeTransactionPointer = (_a = transaction === null || transaction === void 0 ? void 0 : transaction.writeTransactionPointer) !== null && _a !== void 0 ? _a : (await writeTransaction(dittoHandle.deref()));
+            // Ownership is transferred back to the FFI layer via collectionUpdate(),
+            // we therefore need to explicitly unregister the instance.
+            Bridge.mutableDocument.unregister(mutableDocument);
+            await collectionUpdate(dittoHandle.deref(), this.collection.name, writeTransactionPointer, documentPointer);
+            if (!transaction) {
+                await writeTransactionCommit(dittoHandle.deref(), writeTransactionPointer);
+            }
+            return mutableDocument['@ditto.updateResults'].slice();
+        });
+    }
 }
 
 //
@@ -5445,15 +5697,12 @@ class ObserverManager {
         this.isClosed = false;
         this.isRegistered = false;
         this.callbacksByToken = {};
-        if (register !== null) {
+        if (register !== null)
             this.register = register;
-        }
-        if (unregister !== null) {
+        if (unregister !== null)
             this.unregister = unregister;
-        }
-        if (process !== null) {
+        if (process !== null)
             this.process = process;
-        }
     }
     /** @internal */
     addObserver(callback) {
@@ -5511,9 +5760,8 @@ class ObserverManager {
     /** @internal */
     close() {
         this.isClosed = true;
-        for (const token in this.callbacksByToken) {
+        for (const token in this.callbacksByToken)
             this.removeObserver(token);
-        }
     }
     /**
      * Can be injected and replaced via constructor options.
@@ -5550,9 +5798,8 @@ class ObserverManager {
             this.isRegistered = true;
             this.register(function (...args) {
                 const strongThis = weakThis.deref();
-                if (!strongThis) {
+                if (!strongThis)
                     return;
-                }
                 strongThis.notify(...args);
             });
         }
@@ -5581,12 +5828,35 @@ class Authenticator {
     get status() {
         return this._status;
     }
+    /**
+     * Log in to Ditto with a third-party token.
+     *
+     * Returns a promise that resolves to a `LoginResult` object. When the login
+     * attempt is successful, the `error` property of the response will be `null`,
+     * otherwise it will contain a `DittoError` object with details about the
+     * error.
+     *
+     * If the authentication service provides additional client info, it will be
+     * returned in the `clientInfo` property of the response, whether the login
+     * attempt was successful or not.
+     *
+     * @param token The authentication token required to log in.
+     * @param provider The name of the authentication provider.
+     * @throws {@link DittoError} `authentication/failed-to-authenticate` if the
+     * Ditto instance is closed.
+     * @returns A promise that resolves to a `LoginResult` object.
+     */
+    async login(token, provider) {
+        throw new Error(`Authenticator.login() is abstract and must be implemented by subclasses.`);
+    }
     /**
      * Log in to Ditto with a third-party token. Throws if authentication is not
      * available, which can be checked with {@link loginSupported}.
      *
      * @param token the authentication token required to log in.
      * @param provider the name of the authentication provider.
+     * @deprecated Use {@link login} instead, which provides access to client info
+     * provided by the authentication service.
      */
     loginWithToken(token, provider) {
         throw new Error(`Authenticator.loginWithToken() is abstract and must be implemented by subclasses.`);
@@ -5624,7 +5894,9 @@ class Authenticator {
      */
     observeStatus(callback) {
         const token = this.observerManager.addObserver(callback);
-        return new Observer(this.observerManager, token, { stopsWhenFinalized: true });
+        return new Observer(this.observerManager, token, {
+            stopsWhenFinalized: true,
+        });
     }
     /** @internal */
     constructor(keepAlive) {
@@ -5649,6 +5921,19 @@ class Authenticator {
 // -----------------------------------------------------------------------------
 /** @internal */
 class OnlineAuthenticator extends Authenticator {
+    async login(token, provider) {
+        const ditto = this.ditto.deref();
+        if (!ditto || ditto.isClosed) {
+            throw new DittoError('authentication/failed-to-authenticate', 'Ditto instance is closed');
+        }
+        return ditto.deferCloseAsync(async (dittoHandle) => {
+            const { clientInfo, error: ffiError } = await dittoAuthClientLoginWithTokenAndFeedback(dittoHandle.deref(), token, provider);
+            const error = ffiError != null
+                ? DittoError.fromFFIError(ffiError, 'authentication/failed-to-authenticate')
+                : null;
+            return { clientInfo, error };
+        });
+    }
     async loginWithToken(token, provider) {
         const ditto = this.ditto.deref();
         if (!ditto || ditto.isClosed)
@@ -5685,12 +5970,10 @@ class OnlineAuthenticator extends Authenticator {
     }
     '@ditto.authenticationExpiring'(secondsRemaining) {
         const authenticationHandler = this.authenticationHandler;
-        if (secondsRemaining > 0) {
+        if (secondsRemaining > 0)
             authenticationHandler.authenticationExpiringSoon(this, secondsRemaining);
-        }
-        else {
+        else
             authenticationHandler.authenticationRequired(this);
-        }
     }
     '@ditto.authClientValidityChanged'(isWebValid, isX509Valid) {
         this.updateAndNotify(true);
@@ -5726,6 +6009,9 @@ class OnlineAuthenticator extends Authenticator {
 // -----------------------------------------------------------------------------
 /** @internal */
 class NotAvailableAuthenticator extends Authenticator {
+    async login(token, provider) {
+        throw new Error(`Can't login, authentication is not supported for the identity in use, please use an onlineWithAuthentication identity.`);
+    }
     async loginWithToken(token, provider) {
         throw new Error(`Can't login, authentication is not supported for the identity in use, please use an onlineWithAuthentication identity.`);
     }
@@ -5747,7 +6033,11 @@ class NotAvailableAuthenticator extends Authenticator {
 // Copyright © 2021 DittoLive Incorporated. All rights reserved.
 //
 /** The list of identity types that require activation through an offlineLicenseToken */
-const IdentityTypesRequiringOfflineLicenseToken = ['manual', 'sharedKey', 'offlinePlayground'];
+const IdentityTypesRequiringOfflineLicenseToken = [
+    'manual',
+    'sharedKey',
+    'offlinePlayground',
+];
 
 //
 // Copyright © 2021 DittoLive Incorporated. All rights reserved.
@@ -5862,13 +6152,14 @@ function transportConfigToSerializable(config) {
     };
     // Only set the optional properties if they are not undefined
     if (listen.http.staticContentPath) {
-        serialized.listen.http['static_content_path'] = listen.http.staticContentPath;
+        serialized.listen.http['static_content_path'] =
+            listen.http.staticContentPath;
     }
-    if (listen.http.tlsKeyPath) {
+    if (listen.http.tlsKeyPath)
         serialized.listen.http['tls_key_path'] = listen.http.tlsKeyPath;
-    }
     if (listen.http.tlsCertificatePath) {
-        serialized.listen.http['tls_certificate_path'] = listen.http.tlsCertificatePath;
+        serialized.listen.http['tls_certificate_path'] =
+            listen.http.tlsCertificatePath;
     }
     return serialized;
 }
@@ -5975,11 +6266,13 @@ class TransportConfig {
      */
     copy() {
         const copy = new TransportConfig();
-        copy.peerToPeer.bluetoothLE.isEnabled = this.peerToPeer.bluetoothLE.isEnabled;
+        copy.peerToPeer.bluetoothLE.isEnabled =
+            this.peerToPeer.bluetoothLE.isEnabled;
         copy.peerToPeer.awdl.isEnabled = this.peerToPeer.awdl.isEnabled;
         copy.peerToPeer.lan.isEnabled = this.peerToPeer.lan.isEnabled;
         copy.peerToPeer.lan.isMdnsEnabled = this.peerToPeer.lan.isMdnsEnabled;
-        copy.peerToPeer.lan.isMulticastEnabled = this.peerToPeer.lan.isMulticastEnabled;
+        copy.peerToPeer.lan.isMulticastEnabled =
+            this.peerToPeer.lan.isMulticastEnabled;
         copy.connect.tcpServers = this.connect.tcpServers.slice();
         copy.connect.websocketURLs = this.connect.websocketURLs.slice();
         copy.connect.retryInterval = this.connect.retryInterval;
@@ -5994,28 +6287,23 @@ class TransportConfig {
      * returns `false`.
      */
     static areListenTCPsEqual(left, right) {
-        /* eslint-disable */
-        // prettier-ignore
         return (left.isEnabled === right.isEnabled &&
             left.interfaceIP === right.interfaceIP &&
             left.port === right.port);
-        /* eslint-enable */
     }
     /**
      * Returns `true` if passed in HTTP configurations are equal, otherwise
      * returns `false`.
      */
     static areListenHTTPsEqual(left, right) {
-        /* eslint-disable */
-        // prettier-ignore
         return (left.isEnabled === right.isEnabled &&
             left.interfaceIP === right.interfaceIP &&
             left.port === right.port &&
+            // Optional properties
             left.staticContentPath === right.staticContentPath &&
             left.websocketSync === right.websocketSync &&
             left.tlsKeyPath === right.tlsKeyPath &&
             left.tlsCertificatePath === right.tlsCertificatePath);
-        /* eslint-enable */
     }
 }
 
@@ -6103,7 +6391,11 @@ class AttachmentFetcher {
                 resolve(attachment);
             };
             const onProgress = (downloaded, toDownload) => {
-                eventHandlerOrNoOp({ type: 'Progress', totalBytes: toDownload, downloadedBytes: downloaded });
+                eventHandlerOrNoOp({
+                    type: 'Progress',
+                    totalBytes: toDownload,
+                    downloadedBytes: downloaded,
+                });
             };
             const onDelete = () => {
                 eventHandlerOrNoOp({ type: 'Deleted' });
@@ -6124,7 +6416,9 @@ class AttachmentFetcher {
             // cancelled through `this.stop()` so we use this function to reject the
             // promise from the outside.
             this.rejectPendingFetch = () => {
-                const err = this.manager != null ? new Error('Attachment fetch was canceled') : new DittoError('store/failed-to-fetch-attachment', 'Attachment fetch was canceled');
+                const err = this.manager != null
+                    ? new Error('Attachment fetch was canceled')
+                    : new DittoError('store/failed-to-fetch-attachment', 'Attachment fetch was canceled');
                 reject(err);
             };
             // `cancelTokenPromise` resolves once the fetcher has been initialised in
@@ -6144,9 +6438,18 @@ class AttachmentFetcher {
             this.cancelTokenPromise = (async () => {
                 try {
                     return await mapFFIErrorsAsync(async () => dittoResolveAttachment(dittoHandle.deref(), token.idBytes, { onComplete, onProgress, onDelete }, onError), {
-                        1: ['store/failed-to-fetch-attachment', 'Failed to fetch the attachment.'],
-                        2: ['store/attachment-token-invalid', 'The attachment token was invalid.'],
-                        3: ['store/attachment-not-found', 'The attachment was not found.'],
+                        1: [
+                            'store/failed-to-fetch-attachment',
+                            'Failed to fetch the attachment.',
+                        ],
+                        2: [
+                            'store/attachment-token-invalid',
+                            'The attachment token was invalid.',
+                        ],
+                        3: [
+                            'store/attachment-not-found',
+                            'The attachment was not found.',
+                        ],
                     });
                 }
                 catch (e) {
@@ -6154,7 +6457,8 @@ class AttachmentFetcher {
                     // Legacy behavior: when the attachment is deleted before the fetch is
                     // started, the fetcher is stopped and the promise is resolved to
                     // `null`.
-                    if (e instanceof DittoError && e.code === 'store/attachment-not-found') {
+                    if (e instanceof DittoError &&
+                        e.code === 'store/attachment-not-found') {
                         isDeleted = true;
                         eventHandlerOrNoOp({ type: 'Deleted' });
                     }
@@ -6168,19 +6472,16 @@ class AttachmentFetcher {
                     }
                     // When this is called from legacy `Collection.fetchAttachment()`, we
                     // convert the DittoError to a regular Error.
-                    if (strongThis.manager != null && e instanceof DittoError) {
+                    if (strongThis.manager != null && e instanceof DittoError)
                         e = new Error(e.message);
-                    }
                     strongThis.rejectPendingFetch = null;
                     // Reject the `attachment` promise to signal that the fetch has
                     // failed, unless this is a legacy fetcher and the attachment was
                     // deleted.
-                    if (strongThis.manager != null && isDeleted) {
+                    if (strongThis.manager != null && isDeleted)
                         resolve(null);
-                    }
-                    else {
+                    else
                         reject(e);
-                    }
                     // Set cancelTokenPromise to null to indicate that there is nothing to
                     // cancel anymore.
                     return null;
@@ -6220,6 +6521,11 @@ class AttachmentFetcher {
  * While {@link Subscription} objects remain in scope they ensure that
  * documents in the collection specified and that match the query provided will
  * try to be kept up-to-date with the latest changes from remote peers.
+ *
+ * This class is used by Ditto's query builder APIs.
+ * @see {@link SyncSubscription} for the DQL equivalent.
+ *
+ * Not available in React Native environments.
  */
 class Subscription {
     /**
@@ -6273,6 +6579,8 @@ class Subscription {
 /**
  * First event fired immediately after registering a live query without any
  * mutations. All subsequent events are of type {@link LiveQueryEventUpdate}.
+ *
+ * Not available in React Native environments.
  */
 class LiveQueryEventInitial {
     constructor() {
@@ -6308,11 +6616,14 @@ class LiveQueryEventInitial {
 /**
  * Represents an update event describing all changes that occured for documents
  * covered by a (live) query.
+ *
+ * Not available in React Native environments.
  */
 class LiveQueryEventUpdate {
     /**
      * Returns a hash that represents the set of matching documents.
      *
+     * @throws {Error} when called in a React Native environment.
      * @deprecated use {@link Document.hash | Document.hash()} instead.
      */
     hash(documents) {
@@ -6324,6 +6635,7 @@ class LiveQueryEventUpdate {
      * Returns a pattern of words that together create a mnemonic, which
      * represents the set of matching documents.
      *
+     * @throws {Error} when called in a React Native environment.
      * @deprecated use {@link Document.hashMnemonic | Document.hashMnemonic()} instead.
      */
     hashMnemonic(documents) {
@@ -6395,6 +6707,8 @@ class SingleDocumentLiveQueryEvent {
  * your event handler be called when there is an update to a document matching
  * the query you provide. When you no longer want to receive updates about
  * documents matching a query then you must call {@link stop | stop()}.
+ *
+ * Not available in React Native environments.
  */
 class LiveQuery {
     /** The name of the collection that the live query is based on. */
@@ -6407,11 +6721,12 @@ class LiveQuery {
     }
     /**
      * Stop the live query from delivering updates.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     stop() {
-        if (!this.isStopped) {
+        if (!this.isStopped)
             this.liveQueryManager.stopLiveQuery(this);
-        }
     }
     get liveQueryID() {
         return this._liveQueryID;
@@ -6450,10 +6765,16 @@ class LiveQuery {
                 else {
                     event = new LiveQueryEventUpdate({
                         oldDocuments: cCBParams.old_documents.map((ptr) => Bridge.document.bridge(ptr)),
+                        // We don't need to bridge these indices which are returned from FFI
+                        // as JS values and not as pointers. c.f.
+                        // https://dittolive.slack.com/archives/C01NLL95095/p1720609380387539
                         insertions: cCBParams.insertions,
                         deletions: cCBParams.deletions,
                         updates: cCBParams.updates,
-                        moves: cCBParams.moves.map((move) => ({ from: move[0], to: move[1] })),
+                        moves: cCBParams.moves.map((move) => ({
+                            from: move[0],
+                            to: move[1],
+                        })),
                     });
                 }
                 // We discard the return promise because error-handling is not supported.
@@ -6495,6 +6816,8 @@ class LiveQuery {
  * preceding `find`-like call.
  *
  * Update and remove functionality is also exposed through this object.
+ *
+ * Not available in React Native environments.
  */
 class PendingCursorOperation extends BasePendingCursorOperation {
     sort(propertyPath, direction = 'ascending') {
@@ -6540,10 +6863,7 @@ class PendingCursorOperation extends BasePendingCursorOperation {
         const ditto = this.collection.store.ditto;
         return ditto.deferCloseAsync(async (dittoHandle) => {
             return await performAsyncToWorkaroundNonAsyncFFIAPI(async () => {
-                const writeTransactionX = await writeTransaction(dittoHandle.deref());
-                const results = await super.updateWithTransaction(closure, writeTransactionX);
-                await writeTransactionCommit(dittoHandle.deref(), writeTransactionX);
-                return results;
+                return await super.updateWithClosure(closure, 'cursor operation update()');
             });
         });
     }
@@ -6558,6 +6878,8 @@ class PendingCursorOperation extends BasePendingCursorOperation {
      * The returned {@link Subscription} object must be kept in scope for as long
      * as you want to keep receiving updates.
      *
+     * @throws {Error} when called in a React Native environment.
+     *
      * @returns A {@link Subscription} object that must be kept in scope for as
      * long as you want to keep receiving updates for documents that match the
      * query specified in the preceding chain.
@@ -6588,6 +6910,8 @@ class PendingCursorOperation extends BasePendingCursorOperation {
      * transaction committed to the store that involves modifications to documents
      * matching the query in the collection this method was called on.
      *
+     * @throws {Error} when called in a React Native environment.
+     *
      * @return A {@link LiveQuery} object that must be kept in scope for as long
      * as you want to keep receiving updates.
      */
@@ -6617,6 +6941,8 @@ class PendingCursorOperation extends BasePendingCursorOperation {
      * documents matching the query in the collection that this method was called
      * on.
      *
+     * @throws {Error} when called in a React Native environment.
+     *
      * @return A {@link LiveQuery} object that must be kept in scope for as long
      * as you want to keep receiving updates.
      */
@@ -6638,7 +6964,9 @@ class PendingCursorOperation extends BasePendingCursorOperation {
                 nextSignal();
             }
         }
-        const handlerOrWrapped = waitForNextSignal ? handler : wrappedHandler;
+        const handlerOrWrapped = waitForNextSignal
+            ? handler
+            : wrappedHandler;
         const liveQuery = new LiveQuery(this.query, this.queryArgs, this.queryArgsCBOR, this.orderBys, this.currentLimit, this.currentOffset, this.collection, handlerOrWrapped);
         this.collection.store.ditto.liveQueryManager.startLiveQuery(liveQuery);
         return liveQuery;
@@ -6693,23 +7021,10 @@ class PendingIDSpecificOperation extends BasePendingIDSpecificOperation {
         });
     }
     async update(closure) {
-        const ditto = this.collection.store.ditto;
-        return ditto.deferCloseAsync(async (dittoHandle) => {
-            const readTransactionX = await readTransaction(dittoHandle.deref());
-            const documentX = await collectionGet(dittoHandle.deref(), this.collection.name, this.documentIDCBOR, readTransactionX);
-            readTransactionFree(readTransactionX);
-            if (!documentX)
-                throw new Error(`Can't update, document with ID '${this.documentID.toString()}' not found in collection named '${this.collection.name}'`);
-            const mutableDocument = Bridge.mutableDocument.bridge(documentX, () => new MutableDocument());
-            closure(mutableDocument);
-            // Ownership is transferred back to the FFI layer via collectionUpdate(),
-            // we therefore need to explicitly unregister the instance.
-            Bridge.mutableDocument.unregister(mutableDocument);
-            const writeTransactionX = await writeTransaction(dittoHandle.deref());
-            await collectionUpdate(dittoHandle.deref(), this.collection.name, writeTransactionX, documentX);
-            await writeTransactionCommit(dittoHandle.deref(), writeTransactionX);
-            return mutableDocument['@ditto.updateResults'].slice();
-        });
+        return this.updateWithClosure(closure, false, true, 'ID-specific cursor operation update()');
+    }
+    async updateV2(closure) {
+        return this.updateWithClosure(closure, true, false, 'ID-specific cursor operation updateV2()');
     }
     /**
      * Enables you to subscribe to changes that occur in relation to a document
@@ -6791,19 +7106,29 @@ class PendingIDSpecificOperation extends BasePendingIDSpecificOperation {
             if (documents.length > 1) {
                 throw new Error(`Internal inconsistency, single document live query returned more than one document. Query: ${this.query}}.`);
             }
-            if (event.isInitial === false && event.oldDocuments.length > 1)
+            if (event.isInitial === false && event.oldDocuments.length > 1) {
                 throw new Error(`Internal inconsistency, single document live query returned an update event with more than one old documents. Query ${this.query}.`);
-            if (event.isInitial === false && event.insertions.length > 1)
+            }
+            if (event.isInitial === false && event.insertions.length > 1) {
                 throw new Error(`Internal inconsistency, single document live query returned an update event with more than one insertion, which doesn't make sense for single document observations. Query ${this.query}.`);
-            if (event.isInitial === false && event.deletions.length > 1)
+            }
+            if (event.isInitial === false && event.deletions.length > 1) {
                 throw new Error(`Internal inconsistency, single document live query returned an update event with more than one deletion, which doesn't make sense for single document observations. Query ${this.query}.`);
-            if (event.isInitial === false && event.updates.length > 1)
+            }
+            if (event.isInitial === false && event.updates.length > 1) {
                 throw new Error(`Internal inconsistency, single document live query returned an update event with more than one update, which doesn't make sense for single document observations. Query ${this.query}.`);
-            if (event.isInitial === false && event.moves.length > 0)
+            }
+            if (event.isInitial === false && event.moves.length > 0) {
                 throw new Error(`Internal inconsistency, single document live query returned an update event with moves, which doesn't make sense for single document observations. Query ${this.query}.`);
-            const totalNumberOfManipulations = event.isInitial === true ? 0 : event.insertions.length + event.deletions.length + event.updates.length;
-            if (totalNumberOfManipulations > 1)
+            }
+            const totalNumberOfManipulations = event.isInitial === true
+                ? 0
+                : event.insertions.length +
+                    event.deletions.length +
+                    event.updates.length;
+            if (totalNumberOfManipulations > 1) {
                 throw new Error(`Internal inconsistency, single document live query returned a combination of inserts, updates, and/or deletes, which doesn't make sense for single document observation. Query ${this.query}.`);
+            }
             // IDEA: use `undefined` instead of `null` and
             // adapt Wasm variant plus API definition.
             const document = documents[0] || null;
@@ -6836,6 +7161,8 @@ class PendingIDSpecificOperation extends BasePendingIDSpecificOperation {
  * querying a collection. You can get a collection by calling
  * {@link Store.collection | collection()} on a {@link Store} of a {@link Ditto}
  * object.
+ *
+ * Not available in React Native environments.
  */
 class Collection {
     /**
@@ -6856,6 +7183,7 @@ class Collection {
      * Find more information about the query string format in the documentation's
      * section on {@link https://docs.ditto.live/javascript/common/concepts/querying Querying}
      *
+     * @throws {Error} when called in a React Native environment.
      * @param query The query to run against the collection.
      * @param queryArgs The arguments to use to replace placeholders in the
      * provided query.
@@ -6878,6 +7206,7 @@ class Collection {
      * remove or evict the document.
      *
      * @param id The ID of the document to find.
+     * @throws {Error} when called in a React Native environment.
      */
     findByID(id) {
         const documentID = id instanceof DocumentID ? id : new DocumentID(id);
@@ -6918,9 +7247,10 @@ class Collection {
      *
      * @param pathOrData The path to the file that you want to create an
      * attachment with or the raw data.
-     *
      * @param metadata Metadata relating to the attachment.
      *
+     * @throws {Error} when called in a React Native environment.
+     *
      * @deprecated Use {@link Store.newAttachment | ditto.store.newAttachment() }
      * instead.
      */
@@ -6938,7 +7268,11 @@ class Collection {
                 }
                 throw new Error(`Can't create new attachment, only file path as string or raw data as Uint8Array are supported, but got: ${typeof pathOrData}, ${pathOrData}`);
             })();
-            const attachmentTokenJSON = { _id: id, _len: len, _meta: { ...metadata } };
+            const attachmentTokenJSON = {
+                _id: id,
+                _len: len,
+                _meta: { ...metadata },
+            };
             attachmentTokenJSON[DittoCRDTTypeKey] = DittoCRDTType.attachment;
             const attachmentToken = new AttachmentToken(attachmentTokenJSON);
             const attachment = new Attachment(ditto, attachmentToken);
@@ -6961,10 +7295,11 @@ class Collection {
      *
      * @param token The {@link AttachmentToken} relevant to the attachment that
      * you wish to download and observe. Throws if token is invalid.
-     *
      * @param eventHandler An optional callback that will be called when there is
      * an update to the status of the attachment fetch attempt.
      *
+     * @throws {Error} when called in a React Native environment.
+     *
      * @return An `AttachmentFetcher` object, which must be kept alive for the
      * fetch request to proceed and for you to be notified about the attachment's
      * fetch status changes.
@@ -6973,9 +7308,8 @@ class Collection {
      * {@link Store.fetchAttachment | ditto.store.fetchAttachment() } instead.
      */
     fetchAttachment(token, eventHandler) {
-        if (token == null || !(token instanceof AttachmentToken)) {
+        if (token == null || !(token instanceof AttachmentToken))
             throw new Error(`Invalid attachment token: ${token}`);
-        }
         const ditto = this.store.ditto;
         return ditto.deferClose(() => {
             return ditto.attachmentFetcherManager.startAttachmentFetcher(token, eventHandler);
@@ -7084,7 +7418,9 @@ class StoreObserver {
          */
         this._isCancelled = false;
         this.queryString = query;
-        this.queryArguments = queryArguments ? Object.freeze({ ...queryArguments }) : undefined;
+        this.queryArguments = queryArguments
+            ? Object.freeze({ ...queryArguments })
+            : undefined;
         this.ditto = ditto;
         let queryArgumentsCBOR = null;
         if (queryArguments != null) {
@@ -7149,6 +7485,8 @@ class StoreObserver {
  * the collections that were previously known about in the previous event, along
  * with information about what collections have been inserted, deleted, updated,
  * or moved since the last event.
+ *
+ * Not available in React Native environments.
  */
 class CollectionsEvent {
     /** @internal */
@@ -7196,6 +7534,8 @@ class CollectionsEvent {
  * A subscription, established by calling {@link subscribe | subscribe()}, will
  * act as a signal to other peers that the device connects to that you would
  * like to receive updates from them about the collections that they know about.
+ *
+ * Not available in React Native environments.
  */
 class PendingCollectionsOperation {
     /**
@@ -7207,6 +7547,8 @@ class PendingCollectionsOperation {
      * @param direction Specify whether you want the sorting order to be
      * `Ascending` or `Descending`.
      *
+     * @throws {Error} when called in a React Native environment.
+     *
      * @return A {@link PendingCollectionsOperation} that you can chain further
      * function calls to.
      */
@@ -7227,6 +7569,8 @@ class PendingCollectionsOperation {
      * @param offset The number of collections that you want the eventual
      * resulting set of collections to be offset by (and thus not include).
      *
+     * @throws {Error} when called in a React Native environment.
+     *
      * @return A {@link PendingCollectionsOperation} that you can chain further
      * function calls to.
      */
@@ -7241,6 +7585,8 @@ class PendingCollectionsOperation {
      *
      * @param limit The maximum number of collections that will be returned.
      *
+     * @throws {Error} when called in a React Native environment.
+     *
      * @return A {@link PendingCollectionsOperation} that you can chain further
      * function calls to.
      */
@@ -7257,6 +7603,8 @@ class PendingCollectionsOperation {
      * The returned {@link Subscription} object must be kept in scope for as long
      * as you want to keep receiving updates.
      *
+     * @throws {Error} when called in a React Native environment.
+     *
      * @return A {@link Subscription} object that must be kept in scope for as
      * long as you want to keep receiving updates from other devices about the
      * collections that they know about.
@@ -7279,6 +7627,8 @@ class PendingCollectionsOperation {
      * @param handler A closure that will be called every time there is an update
      * about the list of known about collections.
      *
+     * @throws {Error} when called in a React Native environment.
+     *
      * @return A {@link LiveQuery} object that must be kept in scope for as long
      * as you want to keep receiving updates.
      */
@@ -7300,6 +7650,8 @@ class PendingCollectionsOperation {
      * @param handler A closure that will be called every time there is an update
      * about the list of known about collections.
      *
+     * @throws {Error} when called in a React Native environment.
+     *
      * @return A {@link LiveQuery} object that must be kept in scope for as long
      * as you want to keep receiving updates.
      */
@@ -7310,6 +7662,8 @@ class PendingCollectionsOperation {
      * Return the list of collections requested based on the preceding function
      * chaining.
      *
+     * @throws {Error} when called in a React Native environment.
+     *
      * @return A list of {@link Collection}s based on the preceding function
      * chaining.
      */
@@ -7332,9 +7686,8 @@ class PendingCollectionsOperation {
         const weakStore = new WeakRef(this.store);
         const collectionsObservationHandler = function (documents, event, nextSignal) {
             const strongStore = weakStore.deref();
-            if (!strongStore) {
+            if (!strongStore)
                 return;
-            }
             const collections = collectionsFromDocuments(documents, strongStore);
             let collEvent;
             if (event.isInitial === true) {
@@ -7354,12 +7707,10 @@ class PendingCollectionsOperation {
             }
             // The handler return promises are ignored here because we are not
             // handling errors during handler execution.
-            if (waitForNextSignal) {
+            if (waitForNextSignal)
                 void handler(collEvent, nextSignal);
-            }
-            else {
+            else
                 void handler(collEvent);
-            }
         };
         return this.pendingCursorOperation._observe(collectionsObservationHandler, waitForNextSignal);
     }
@@ -7369,9 +7720,8 @@ function collectionsFromDocuments(documents, store) {
     const collections = [];
     for (const document of documents) {
         const collectionName = document.at('name').value;
-        if (collectionName !== undefined && typeof collectionName === 'string') {
+        if (collectionName !== undefined && typeof collectionName === 'string')
             collections.push(new Collection(collectionName, store));
-        }
     }
     return collections;
 }
@@ -7392,6 +7742,8 @@ function collectionsFromDocuments(documents, store) {
  * or evicting any matching documents.
  *
  * Live queries and subscriptions are only available outside of transactions.
+ *
+ * Not available in React Native environments.
  */
 class WriteTransactionPendingCursorOperation extends BasePendingCursorOperation {
     sort(propertyPath, direction = 'ascending') {
@@ -7407,7 +7759,8 @@ class WriteTransactionPendingCursorOperation extends BasePendingCursorOperation
         const ditto = this.collection.store.ditto;
         return ditto.deferCloseAsync(async (dittoHandle) => {
             const query = this.query;
-            const transaction = this.collection.writeTransaction;
+            const transaction = this.collection
+                .writeTransaction;
             const documentsX = await performAsyncToWorkaroundNonAsyncFFIAPI(async () => collectionRemoveQueryStr(dittoHandle.deref(), this.collection.name, transaction.writeTransactionPointer, query, this.queryArgsCBOR, this.orderBys, this.currentLimit, this.currentOffset));
             const results = documentsX.map((idCBOR) => {
                 return new DocumentID(idCBOR, true);
@@ -7422,7 +7775,8 @@ class WriteTransactionPendingCursorOperation extends BasePendingCursorOperation
         const ditto = this.collection.store.ditto;
         return ditto.deferCloseAsync(async (dittoHandle) => {
             const query = this.query;
-            const transaction = this.collection.writeTransaction;
+            const transaction = this.collection
+                .writeTransaction;
             const documentsX = await performAsyncToWorkaroundNonAsyncFFIAPI(async () => collectionEvictQueryStr(dittoHandle.deref(), this.collection.name, transaction.writeTransactionPointer, query, this.queryArgsCBOR, this.orderBys, this.currentLimit, this.currentOffset));
             const results = documentsX.map((idCBOR) => {
                 return new DocumentID(idCBOR, true);
@@ -7434,8 +7788,9 @@ class WriteTransactionPendingCursorOperation extends BasePendingCursorOperation
         });
     }
     async update(closure) {
-        const transaction = this.collection.writeTransaction;
-        const results = await super.updateWithTransaction(closure, transaction.writeTransactionPointer);
+        const transaction = this.collection
+            .writeTransaction;
+        const results = await super.updateWithClosure(closure, 'write transaction cursor operation update()', transaction.writeTransactionPointer);
         results.keys().forEach((documentId) => {
             transaction.addResult('updated', documentId, this.collection.name);
         });
@@ -7455,7 +7810,8 @@ class WriteTransactionPendingIDSpecificOperation extends BasePendingIDSpecificOp
     async remove() {
         const ditto = this.collection.store.ditto;
         return ditto.deferCloseAsync(async (dittoHandle) => {
-            const transaction = this.collection.writeTransaction;
+            const transaction = this.collection
+                .writeTransaction;
             const result = await performAsyncToWorkaroundNonAsyncFFIAPI(async () => collectionRemove(dittoHandle.deref(), this.collection.name, transaction.writeTransactionPointer, this.documentIDCBOR));
             transaction.addResult('removed', this.documentID, this.collection.name);
             return result;
@@ -7464,30 +7820,26 @@ class WriteTransactionPendingIDSpecificOperation extends BasePendingIDSpecificOp
     async evict() {
         const ditto = this.collection.store.ditto;
         return ditto.deferCloseAsync(async (dittoHandle) => {
-            const transaction = this.collection.writeTransaction;
+            const transaction = this.collection
+                .writeTransaction;
             const result = await performAsyncToWorkaroundNonAsyncFFIAPI(async () => await collectionEvict(dittoHandle.deref(), this.collection.name, transaction.writeTransactionPointer, this.documentIDCBOR));
             transaction.addResult('evicted', this.documentID, this.collection.name);
             return result;
         });
     }
     async update(closure) {
-        const ditto = this.collection.store.ditto;
-        return ditto.deferCloseAsync(async (dittoHandle) => {
-            const transaction = this.collection.writeTransaction;
-            const readTransactionX = await readTransaction(dittoHandle.deref());
-            const documentX = await collectionGet(dittoHandle.deref(), this.collection.name, this.documentIDCBOR, readTransactionX);
-            readTransactionFree(readTransactionX);
-            if (!documentX)
-                throw new Error(`Can't update, document with ID '${this.documentID.toString()}' not found in collection named '${this.collection.name}'`);
-            const mutableDocument = Bridge.mutableDocument.bridge(documentX, () => new MutableDocument());
-            closure(mutableDocument);
-            // Ownership is transferred back to the FFI layer via collectionUpdate(),
-            // we therefore need to explicitly unregister the instance.
-            Bridge.mutableDocument.unregister(mutableDocument);
-            await collectionUpdate(dittoHandle.deref(), this.collection.name, transaction.writeTransactionPointer, documentX);
-            transaction.addResult('updated', this.documentID, this.collection.name);
-            return mutableDocument['@ditto.updateResults'].slice();
-        });
+        const transaction = this.collection
+            .writeTransaction;
+        const updateResults = this.updateWithClosure(closure, false, true, 'write transaction cursor operation update()', transaction);
+        transaction.addResult('updated', this.documentID, this.collection.name);
+        return updateResults;
+    }
+    async updateV2(closure) {
+        const transaction = this.collection
+            .writeTransaction;
+        const updateResults = this.updateWithClosure(closure, true, false, 'write transaction cursor operation updateV2()', transaction);
+        transaction.addResult('updated', this.documentID, this.collection.name);
+        return updateResults;
     }
     // ----------------------------------------------------------- Internal ------
     /** @internal */
@@ -7509,6 +7861,8 @@ class WriteTransactionPendingIDSpecificOperation extends BasePendingIDSpecificOp
  *
  * Create a `WriteTransactionCollection` by starting a {@link WriteTransaction}
  * and using its `scoped` method.
+ *
+ * Not available in React Native environments.
  */
 class WriteTransactionCollection {
     /**
@@ -7520,6 +7874,7 @@ class WriteTransactionCollection {
      * @param query The query to run against the collection.
      * @param queryArgs These arguments replace placeholders in the provided
      * query.
+     * @throws {Error} when called in a React Native environment.
      */
     find(query, queryArgs) {
         return new WriteTransactionPendingCursorOperation(query, queryArgs !== null && queryArgs !== void 0 ? queryArgs : null, this);
@@ -7527,6 +7882,8 @@ class WriteTransactionCollection {
     /**
      * Convenience method, equivalent to calling {@link find | find()} and passing
      * the query `"true"`.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     findAll() {
         return this.find('true');
@@ -7538,6 +7895,7 @@ class WriteTransactionCollection {
      * The returned object can be used to find and return the document. It can also be used to update, remove or evict the document.
      *
      * @param id The ID of the document to find.
+     * @throws {Error} when called in a React Native environment.
      */
     findByID(id) {
         const documentID = id instanceof DocumentID ? id : new DocumentID(id);
@@ -7594,11 +7952,12 @@ class WriteTransaction {
      * provided to this function. You can create many
      * {@link WriteTransactionCollection | collection} objects per
      * {@link WriteTransaction} object.
+     *
+     * @throws {Error} when called in a React Native environment.
      * */
     scoped(toCollectionNamed) {
-        if (typeof toCollectionNamed !== 'string') {
+        if (typeof toCollectionNamed !== 'string')
             throw new Error('Collection name must be a string');
-        }
         return new WriteTransactionCollection(toCollectionNamed, this.ditto.store, this);
     }
     /** @internal */
@@ -7756,7 +8115,6 @@ class Store {
             return new Promise((resolve) => {
                 void step(async () => {
                     try {
-                        // prettier-ignore
                         await mapFFIErrorsAsync(async () => await liveQueryStart(dittoHandle.deref(), storeObserver.liveQueryID));
                     }
                     catch (error) {
@@ -7779,6 +8137,8 @@ class Store {
      * * it is not empty
      * * it does not contain the char '\0'
      * * it does not begin with "$TS_"
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     collection(name) {
         return new Collection(name, this);
@@ -7789,6 +8149,8 @@ class Store {
      *
      * @return A {@link PendingCollectionsOperation} object that you can use to
      * fetch or observe the collections in the store
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     collections() {
         return new PendingCollectionsOperation(this);
@@ -7796,6 +8158,8 @@ class Store {
     /**
      * Returns the names of all available collections in the store of the
      * related {@link Ditto} instance.
+     *
+     * @throws {Error} when called in a React Native environment.
      */
     collectionNames() {
         return this.ditto.deferClose((dittoHandle) => {
@@ -7845,7 +8209,6 @@ class Store {
                     throw new DittoError('query/arguments-invalid', `Unable to encode query arguments: ${error.message}`);
                 }
             }
-            // prettier-ignore
             const queryResultPointer = await mapFFIErrorsAsync(async () => await performAsyncToWorkaroundNonAsyncFFIAPI(() => tryExecStatement(dittoHandle.deref(), writeTransaction, query, queryArgumentsCBOR)));
             return Bridge.queryResult.bridge(queryResultPointer, () => new QueryResult(queryResultPointer));
         });
@@ -7856,6 +8219,7 @@ class Store {
      * Allows you to group multiple operations together that affect multiple documents, potentially across multiple collections.
      *
      * @param callback is given access to a {@link WriteTransaction | write transaction object} that can be used to perform operations on the store.
+     * @throws {Error} when called in a React Native environment.
      * @returns a list of `WriteTransactionResult`s. There is a result for each operation performed as part of the write transaction.
      */
     async write(callback) {
@@ -7936,9 +8300,8 @@ class Store {
      * attachment from a file path in a web browser.
      */
     async newAttachment(pathOrData, metadata) {
-        if (metadata != null) {
+        if (metadata != null)
             validateAttachmentMetadata(metadata);
-        }
         return this.ditto.deferCloseAsync(async (dittoHandle) => {
             //
             // Create inputs for the attachment token from either a file path or raw data.
@@ -7960,7 +8323,12 @@ class Store {
                 }
                 throw new Error(`Can't create new attachment, only file path as string or raw data as Uint8Array are supported, but got: ${typeof pathOrData}, ${pathOrData}`);
             })();
-            const attachmentTokenJSON = { _id: id, _len: len, _meta: { ...metadata }, [DittoCRDTTypeKey]: DittoCRDTType.attachment };
+            const attachmentTokenJSON = {
+                _id: id,
+                _len: len,
+                _meta: { ...metadata },
+                [DittoCRDTTypeKey]: DittoCRDTType.attachment,
+            };
             const attachmentToken = new AttachmentToken(attachmentTokenJSON);
             // this.ditto is safe to use because we are inside a deferCloseAsync block
             const attachment = new Attachment(this.ditto, attachmentToken);
@@ -8026,21 +8394,21 @@ class Store {
      * the attachment fails for other reasons.
      */
     fetchAttachment(token, eventHandler) {
-        if (token == null) {
+        if (token == null)
             throw new Error("Missing required parameter 'token'");
-        }
         let attachmentToken;
-        if (token instanceof AttachmentToken) {
+        if (token instanceof AttachmentToken)
             attachmentToken = token;
-        }
-        else {
+        else
             attachmentToken = new AttachmentToken(token);
-        }
         return this.ditto.deferClose(() => {
             const attachmentFetcher = new AttachmentFetcher(this.ditto, attachmentToken, null, eventHandler);
             // @ts-expect-error modifying readonly property
             // eslint-disable-next-line @typescript-eslint/no-floating-promises
-            this.attachmentFetchers = Object.freeze([...this.attachmentFetchers, attachmentFetcher]);
+            this.attachmentFetchers = Object.freeze([
+                ...this.attachmentFetchers,
+                attachmentFetcher,
+            ]);
             return attachmentFetcher;
         });
     }
@@ -8095,7 +8463,6 @@ class Store {
                 throw new DittoError('query/arguments-invalid', `Invalid query arguments: ${error.message}`);
             }
         }
-        // prettier-ignore
         return this.ditto.deferCloseAsync(async (dittoHandle) => {
             const webhookIDCBOR = await mapFFIErrorsAsync(async () => await tryRegisterStoreObserverWebhook(dittoHandle.deref(), query, queryArgumentsCBOR, url));
             return new DocumentID(webhookIDCBOR, true);
@@ -8126,16 +8493,14 @@ class Store {
         }
         // Return early if the store observer has already been removed.
         const indexToDelete = this.observers.findIndex((observer) => observer === storeObserver);
-        if (indexToDelete === -1) {
+        if (indexToDelete === -1)
             return false;
-        }
         const newObservers = [...this.observers];
         newObservers.splice(indexToDelete, 1);
         // @ts-expect-error modifying readonly property
         this.observers = Object.freeze(newObservers);
         const dittoHandle = Bridge.ditto.handleFor(this.ditto);
         this.ditto.deferClose(() => {
-            // prettier-ignore
             mapFFIErrors(() => liveQueryStop(dittoHandle.deref(), storeObserver.liveQueryID));
         });
         return true;
@@ -8162,9 +8527,8 @@ class Store {
             throw new DittoError('internal', "Internal inconsistency, can't remove attachment fetcher that has not stopped");
         }
         const indexToDelete = this.attachmentFetchers.findIndex((fetcher) => fetcher === attachmentFetcher);
-        if (indexToDelete === -1) {
+        if (indexToDelete === -1)
             return false;
-        }
         const newAttachmentFetchers = [...this.attachmentFetchers];
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
         newAttachmentFetchers.splice(indexToDelete, 1);
@@ -8175,12 +8539,10 @@ class Store {
     }
     /** @internal */
     close() {
-        for (const observer of this.observers) {
+        for (const observer of this.observers)
             observer.cancel();
-        }
-        for (const fetcher of this.attachmentFetchers) {
+        for (const fetcher of this.attachmentFetchers)
             fetcher.stop();
-        }
         // NOTE: live query webhook is taken care of by the FFI's
         // `ditto_shutdown()`, no need to unregister it here.
     }
@@ -8372,7 +8734,9 @@ class Presence {
      */
     observe(didChangeHandler) {
         const observerToken = this.observerManager.addObserver(didChangeHandler);
-        const observer = new Observer(this.observerManager, observerToken, { stopsWhenFinalized: true });
+        const observer = new Observer(this.observerManager, observerToken, {
+            stopsWhenFinalized: true,
+        });
         // REFACTOR: make the initial callback call async, too (othewise we'd be
         // mixing sync with async, which is a bit problematic in general but might
         // be OK with single-threaded JS). This is a bit tricky, simply
@@ -8472,9 +8836,8 @@ class LiveQueryManager {
         for (const liveQueryID in this.liveQueriesByID) {
             const weakLiveQuery = this.liveQueriesByID[liveQueryID];
             const liveQuery = weakLiveQuery.deref();
-            if (liveQuery) {
+            if (liveQuery)
                 this.stopLiveQuery(liveQuery);
-            }
         }
     }
     stopLiveQueryWithID(liveQueryID) {
@@ -8746,7 +9109,7 @@ class SyncSubscription {
     constructor(ditto, query, queryArguments, queryArgumentsCBOR) {
         // --------------------------- Private --------------------------------------
         /**
-         * `true` when the ssync ubscription has been cancelled.
+         * `true` when the sync subscription has been cancelled.
          *
          * We mark the sync subscription as cancelled here as an optimization to avoid
          * a scan of all subscriptions in the store whenever the `isCancelled`
@@ -8758,7 +9121,9 @@ class SyncSubscription {
         }
         this.ditto = ditto;
         this.queryString = query;
-        this.queryArguments = queryArguments ? Object.freeze({ ...queryArguments }) : undefined;
+        this.queryArguments = queryArguments
+            ? Object.freeze({ ...queryArguments })
+            : undefined;
         this.queryArgumentsCBOR = queryArgumentsCBOR;
     }
 }
@@ -8823,7 +9188,7 @@ class Sync {
     /** @internal */
     constructor(ditto) {
         /**
-         * All currently active sync subscriptions.
+         * All currently active {@link SyncSubscription | sync subscriptions}.
          *
          * **Note:** Manage sync subscriptions using
          * {@link registerSubscription | registerSubscription()} to register a new
@@ -8839,7 +9204,14 @@ class Sync {
         this.mdnsServerAdvertiserPointer = null;
         const identity = ditto.identity;
         const transportConfig = new TransportConfig();
-        const parameters = { identity, transportConfig, ditto, isWebValid: false, isX509Valid: false, isSyncActive: false };
+        const parameters = {
+            identity,
+            transportConfig,
+            ditto,
+            isWebValid: false,
+            isX509Valid: false,
+            isSyncActive: false,
+        };
         this.ditto = ditto;
         this.state = stateFrom(parameters);
         transportsInit();
@@ -8868,15 +9240,13 @@ class Sync {
             throw new DittoError('internal', "Internal inconsistency, can't remove replication subscription that has not been cancelled");
         }
         const indexToDelete = this.subscriptions.findIndex((s) => s === syncSubscription);
-        if (indexToDelete === -1) {
+        if (indexToDelete === -1)
             return false;
-        }
         const newSyncSubscriptions = [...this.subscriptions];
         newSyncSubscriptions.splice(indexToDelete, 1);
         // @ts-expect-error modifying readonly property
         this.subscriptions = Object.freeze(newSyncSubscriptions);
         this.ditto.deferClose((dittoHandle) => {
-            // prettier-ignore
             mapFFIErrors(() => tryRemoveSyncSubscription(dittoHandle.deref(), syncSubscription.queryString, syncSubscription.queryArgumentsCBOR));
         });
         return true;
@@ -8907,9 +9277,8 @@ class Sync {
         if (this.parameters.isSyncActive) {
             throw new Error(`Internal inconsistency, can't close sync object while sync is active, please 'stopSync()' first.`);
         }
-        for (const subscription of this.subscriptions) {
+        for (const subscription of this.subscriptions)
             subscription.cancel();
-        }
         // Nothing to do, when sync is stopped, this object should be
         // already be cleaned up properly.
     }
@@ -8919,10 +9288,12 @@ class Sync {
             const bluetoothLENew = stateNew.effectiveTransportConfig.peerToPeer.bluetoothLE;
             const shouldStart = !bluetoothLEOld.isEnabled && bluetoothLENew.isEnabled;
             const shouldStop = bluetoothLEOld.isEnabled && !bluetoothLENew.isEnabled;
-            if (shouldStart && this.bluetoothLETransportPointer)
+            if (shouldStart && this.bluetoothLETransportPointer) {
                 throw new Error(`Internal inconsistency, when starting BLE transport, no BLE transport pointer should exist.`);
-            if (shouldStop && !this.bluetoothLETransportPointer)
+            }
+            if (shouldStop && !this.bluetoothLETransportPointer) {
                 throw new Error(`Internal inconsistency, when stopping BLE transport, a BLE transport pointer should exist.`);
+            }
             // HACK: quick & dirty Linux & Windows hack. A proper implementation
             // should encapsulate everything behind the transports module. To undo,
             // remove the whole if block.
@@ -8947,7 +9318,8 @@ class Sync {
             }
             if (shouldStop) {
                 // null check is performed above
-                transportsBLEDestroy(this.bluetoothLETransportPointer);
+                transportsBLEDestroy(this
+                    .bluetoothLETransportPointer);
                 this.bluetoothLETransportPointer = null;
             }
         });
@@ -8958,10 +9330,12 @@ class Sync {
             const awdlNew = stateNew.effectiveTransportConfig.peerToPeer.awdl;
             const shouldStart = !awdlOld.isEnabled && awdlNew.isEnabled;
             const shouldStop = awdlOld.isEnabled && !awdlNew.isEnabled;
-            if (shouldStart && this.awdlTransportPointer)
+            if (shouldStart && this.awdlTransportPointer) {
                 throw new Error(`Internal inconsistency, when starting AWDL transport, no AWDL transport pointer should exist.`);
-            if (shouldStop && !this.awdlTransportPointer)
+            }
+            if (shouldStop && !this.awdlTransportPointer) {
                 throw new Error(`Internal inconsistency, when stopping AWDL transport, an AWDL transport pointer should exist.`);
+            }
             if (shouldStart) {
                 this.awdlTransportPointer = transportsAWDLCreate(dittoHandle.deref());
             }
@@ -8982,27 +9356,28 @@ class Sync {
             if (process.platform === 'win32' || process.platform === 'linux') {
                 if (lanOld.isEnabled) {
                     if (lanOld.isMdnsEnabled) {
-                        if (this.mdnsClientTransportPointer == null)
+                        if (this.mdnsClientTransportPointer == null) {
                             throw new Error(`Internal inconsistency, when stopping LAN transport, a LAN transport pointer should exist.`);
+                        }
                         mdnsClientFreeHandle(this.mdnsClientTransportPointer);
                         this.mdnsClientTransportPointer = null;
-                        if (this.mdnsServerAdvertiserPointer == null)
+                        if (this.mdnsServerAdvertiserPointer == null) {
                             throw new Error(`Internal inconsistency, when stopping LAN transport, a LAN transport pointer should exist.`);
+                        }
                         mdnsServerFreeHandle(this.mdnsServerAdvertiserPointer);
                         this.mdnsServerAdvertiserPointer = null;
                     }
-                    if (lanOld.isMulticastEnabled) {
+                    if (lanOld.isMulticastEnabled)
                         dittoRemoveMulticastTransport(dittoHandle.deref());
-                    }
                 }
                 if (lanNew.isEnabled) {
                     if (lanNew.isMdnsEnabled) {
                         this.mdnsClientTransportPointer = dittoAddInternalMdnsTransport(dittoHandle.deref());
-                        this.mdnsServerAdvertiserPointer = dittoAddInternalMdnsAdvertiser(dittoHandle.deref());
+                        this.mdnsServerAdvertiserPointer =
+                            dittoAddInternalMdnsAdvertiser(dittoHandle.deref());
                     }
-                    if (lanNew.isMulticastEnabled) {
+                    if (lanNew.isMulticastEnabled)
                         dittoAddMulticastTransport(dittoHandle.deref());
-                    }
                 }
                 return;
             }
@@ -9010,24 +9385,24 @@ class Sync {
             // via some additional state signaling the actions here.
             if (lanOld.isEnabled) {
                 if (lanOld.isMdnsEnabled) {
-                    if (this.lanTransportPointer == null)
+                    if (this.lanTransportPointer == null) {
                         throw new Error(`Internal inconsistency, when stopping LAN transport, a LAN transport pointer should exist.`);
+                    }
                     transportsLANDestroy(this.lanTransportPointer);
                     this.lanTransportPointer = null;
                 }
-                if (lanOld.isMulticastEnabled) {
+                if (lanOld.isMulticastEnabled)
                     dittoRemoveMulticastTransport(dittoHandle.deref());
-                }
             }
             if (lanNew.isEnabled) {
                 if (lanNew.isMdnsEnabled) {
-                    if (this.lanTransportPointer != null)
+                    if (this.lanTransportPointer != null) {
                         throw new Error(`Internal inconsistency, when starting LAN transport, no LAN transport pointer should exist.`);
+                    }
                     this.lanTransportPointer = transportsLANCreate(dittoHandle.deref());
                 }
-                if (lanNew.isMulticastEnabled) {
+                if (lanNew.isMulticastEnabled)
                     dittoAddMulticastTransport(dittoHandle.deref());
-                }
             }
         });
     }
@@ -9039,8 +9414,9 @@ class Sync {
                 return;
             if (tcpOld.isEnabled)
                 dittoStopTCPServer(dittoHandle.deref());
-            if (tcpNew.isEnabled)
+            if (tcpNew.isEnabled) {
                 dittoStartTCPServer(dittoHandle.deref(), `${tcpNew.interfaceIP}:${tcpNew.port}`);
+            }
         });
     }
     updateListenHTTP(stateOld, stateNew) {
@@ -9073,7 +9449,8 @@ class Sync {
     }
     updateGlobal(stateOld, stateNew) {
         this.ditto.deferClose((dittoHandle) => {
-            if (stateOld.effectiveTransportConfig.global.syncGroup !== stateNew.effectiveTransportConfig.global.syncGroup) {
+            if (stateOld.effectiveTransportConfig.global.syncGroup !==
+                stateNew.effectiveTransportConfig.global.syncGroup) {
                 dittoSetSyncGroup(dittoHandle.deref(), stateNew.effectiveTransportConfig.global.syncGroup);
             }
         });
@@ -9110,7 +9487,8 @@ function stateFrom(parameters) {
     let appID;
     let customDittoCloudURL;
     let isDittoCloudSyncEnabled = false;
-    if (identity.type === 'onlinePlayground' || identity.type === 'onlineWithAuthentication') {
+    if (identity.type === 'onlinePlayground' ||
+        identity.type === 'onlineWithAuthentication') {
         // NOTE: enableDittoCloudSync is true by default for any online identity.
         appID = identity.appID;
         customDittoCloudURL = (_a = identity.customDittoCloudURL) !== null && _a !== void 0 ? _a : null;
@@ -9125,12 +9503,10 @@ function stateFrom(parameters) {
         transportConfig.listen.tcp.isEnabled = false;
         transportConfig.connect.tcpServers = [];
     }
-    if (!isSyncActive || !isWebValid) {
+    if (!isSyncActive || !isWebValid)
         transportConfig.connect.websocketURLs = [];
-    }
-    if (!isSyncActive) {
+    if (!isSyncActive)
         transportConfig.listen.http.isEnabled = false;
-    }
     // NOTE: we have to smuggle in an additional Ditto Cloud websocket URL to
     // connect to if cloud sync is enabled.
     if (isSyncActive && isWebValid && isDittoCloudSyncEnabled) {
@@ -9160,21 +9536,19 @@ function validateEnabledTransportsAvailable(ditto, transportConfig) {
         const isBLEAvailable = transportsBLEIsAvailable(dittoHandle.deref());
         const isAWDLAvailable = transportsAWDLIsAvailable(dittoHandle.deref());
         const isLANAvailable = transportsLANIsAvailable(dittoHandle.deref());
-        if (transportConfig.peerToPeer.bluetoothLE.isEnabled && !isBLEAvailable) {
+        if (transportConfig.peerToPeer.bluetoothLE.isEnabled && !isBLEAvailable)
             unavailableButEnabledP2PTransports.push('BluetoothLE');
-        }
-        if (transportConfig.peerToPeer.awdl.isEnabled && !isAWDLAvailable) {
+        if (transportConfig.peerToPeer.awdl.isEnabled && !isAWDLAvailable)
             unavailableButEnabledP2PTransports.push('AWDL');
-        }
-        if (transportConfig.peerToPeer.lan.isEnabled && !isLANAvailable) {
+        if (transportConfig.peerToPeer.lan.isEnabled && !isLANAvailable)
             unavailableButEnabledP2PTransports.push('LAN');
-        }
         if (unavailableButEnabledP2PTransports.length > 0) {
             throw new Error(`The following P2P transports are enabled in the transport config but are not supported in the current environment: ${unavailableButEnabledP2PTransports.join(', ')}`);
         }
         // - Websocket / HTTP
         // - TCP
-        if (transportConfig.connect.tcpServers.length > 0 && isWebBuild) {
+        if (transportConfig.connect.tcpServers.length > 0 &&
+            isWebBuild) {
             throw new Error(`The transport config contains TCP servers, but this transport is not supported in web environments`);
         }
         if (transportConfig.listen.http.isEnabled && isWebBuild) {
@@ -9397,9 +9771,8 @@ class SmallPeerInfo {
      * @throws when set to a non-boolean value.
      */
     set isEnabled(newValue) {
-        if (typeof newValue !== 'boolean') {
+        if (typeof newValue !== 'boolean')
             throw new TypeError(`Expected boolean, got ${typeof newValue}`);
-        }
         void this.ditto.deferCloseAsync(async (dittoHandle) => {
             return dittoSmallPeerInfoSetEnabled(dittoHandle.deref(), newValue);
         });
@@ -9455,9 +9828,8 @@ class SmallPeerInfo {
      * {@link SmallPeerInfo.metadata | `metadata`}.
      */
     set metadataJSONString(metadata) {
-        if (typeof metadata !== 'string') {
+        if (typeof metadata !== 'string')
             throw new TypeError(`Expected string, got ${typeof metadata}`);
-        }
         this.ditto.deferClose((dittoHandle) => {
             // throws if any validation errors occur
             dittoSmallPeerInfoSetMetadata(dittoHandle.deref(), metadata);
@@ -9560,7 +9932,7 @@ class Ditto {
         return (_a = this._isActivated) !== null && _a !== void 0 ? _a : false;
     }
     /**
-     * `true` once {@link close | Ditto.close()} has been called, otherwise
+     * `true` once {@link Ditto.close | Ditto.close()} has been called, otherwise
      * `false`.
      */
     get isClosed() {
@@ -9609,8 +9981,12 @@ class Ditto {
             throw new Error('Ditto does not support this JavaScript environment. Please consult the Ditto JavaScript documentation for a list of supported environments and browsers. You can use `Ditto.isEnvironmentSupported()` to run this check anytime.');
         }
         loggerInit();
-        this.persistenceDirectory = Ditto.initPersistenceDirectory(persistenceDirectory);
-        const identityOrDefault = identity !== null && identity !== void 0 ? identity : { type: 'offlinePlayground', appID: '' };
+        this.persistenceDirectory =
+            Ditto.initPersistenceDirectory(persistenceDirectory);
+        const identityOrDefault = identity !== null && identity !== void 0 ? identity : {
+            type: 'offlinePlayground',
+            appID: '',
+        };
         const validIdentity = Object.freeze(this.validateIdentity(identityOrDefault));
         this.identity = Object.freeze(validIdentity);
         // Check if device name stays the same on sdk and core levels (#10729).
@@ -9653,12 +10029,10 @@ class Ditto {
         const dittoPointer = dittoMake(this.persistenceDirectory, identityConfig, historyTracking);
         dittoAuthClientSetValidityListener(dittoPointer, function (...args) {
             const ditto = weakThis.deref();
-            if (ditto == null || ditto.isClosed) {
+            if (ditto == null || ditto.isClosed)
                 Logger.info('Ditto is closed, ignoring auth client validity change');
-            }
-            else {
+            else
                 ditto.authClientValidityChanged(...args);
-            }
         });
         const isWebValid = dittoAuthClientIsWebValid(dittoPointer);
         const isX509Valid = dittoAuthClientIsX509Valid(dittoPointer);
@@ -9715,10 +10089,18 @@ class Ditto {
         this.isX509Valid = isX509Valid;
         this.isWebValid = isWebValid;
         this.sync = new Sync(this);
-        this.sync.update({ isSyncActive: false, isX509Valid, isWebValid, identity: validIdentity, ditto: this, transportConfig });
+        this.sync.update({
+            isSyncActive: false,
+            isX509Valid,
+            isWebValid,
+            identity: validIdentity,
+            ditto: this,
+            transportConfig,
+        });
         // We don't need a license when running in the browser, so we
         // mark the instance as activated from the get-go in that case.
-        this._isActivated = !IdentityTypesRequiringOfflineLicenseToken.includes(validIdentity.type);
+        this._isActivated =
+            !IdentityTypesRequiringOfflineLicenseToken.includes(validIdentity.type);
         this.store = new Store(this);
         this.smallPeerInfo = new SmallPeerInfo(this);
         this.presence = new Presence(this);
@@ -9748,7 +10130,7 @@ class Ditto {
      * disables this behavior, thus allowing the use of an interactive debugger
      * without triggering the deadlock detection.
      *
-     * This feature is not available in the browser.
+     * This feature is only available in Node.js environments.
      */
     static disableDeadlockDetection() {
         {
@@ -9770,15 +10152,13 @@ class Ditto {
      * {@link Ditto.disableDeadlockDetection | Ditto.disableDeadlockDetection()}
      * for more information.
      *
-     * This method always returns `false` in the browser where deadlock detection
-     * is not available.
+     * When called outside of a Node.js environment, this method always returns
+     * `false` as deadlock detection is only available in Node.js.
      *
      * @returns `true` if deadlock detection is enabled
      */
     static hasDeadlockDetection() {
-        {
-            return getDeadlockTimeout() !== 0;
-        }
+        return getDeadlockTimeout() !== 0;
     }
     /**
      * Check if the current environment supports running Ditto.
@@ -9796,8 +10176,13 @@ class Ditto {
     static isEnvironmentSupported() {
         // From https://stackoverflow.com/questions/21825157/internet-explorer-11-detection
         let isIE = false;
-        if (typeof window !== 'undefined' && window.navigator && window.navigator.userAgent && window.navigator.appVersion) {
-            isIE = window.navigator.userAgent.indexOf('MSIE') !== -1 || window.navigator.appVersion.indexOf('Trident/') > -1;
+        if (typeof window !== 'undefined' &&
+            window.navigator &&
+            window.navigator.userAgent &&
+            window.navigator.appVersion) {
+            isIE =
+                window.navigator.userAgent.indexOf('MSIE') !== -1 ||
+                    window.navigator.appVersion.indexOf('Trident/') > -1;
         }
         let hasRequiredAPIs;
         try {
@@ -9821,15 +10206,12 @@ class Ditto {
      */
     static initPersistenceDirectory(path) {
         let validatedPath;
-        if (path == null) {
+        if (path == null)
             validatedPath = DEFAULT_PERSISTENCE_DIRECTORY;
-        }
-        else if (path.trim().length === 0) {
+        else if (path.trim().length === 0)
             throw new Error(`Invalid argument for path parameter: '${path}'`);
-        }
-        else {
+        else
             validatedPath = path;
-        }
         {
             const fs = require('fs');
             const path = require('path');
@@ -9919,7 +10301,14 @@ class Ditto {
         const identity = this.identity;
         const isWebValid = this.isWebValid;
         const isX509Valid = this.isX509Valid;
-        this.sync.update({ transportConfig: transportConfigNew, identity, isWebValid, isX509Valid, isSyncActive: this.isSyncActive, ditto: this });
+        this.sync.update({
+            transportConfig: transportConfigNew,
+            identity,
+            isWebValid,
+            isX509Valid,
+            isSyncActive: this.isSyncActive,
+            ditto: this,
+        });
         const configSerializeReady = transportConfigToSerializable(transportConfigNew);
         const configCBOR = CBOR.encode(configSerializeReady);
         this.deferClose((dittoHandle) => {
@@ -9942,9 +10331,9 @@ class Ditto {
      *
      * By default Ditto will enable all peer-to-peer transport types. On **Node**,
      * this means BluetoothLE, WiFi/LAN, and AWDL. On the **Web**, only connecting
-     * via  Websockets is supported. The network configuration can be
-     * customized with {@link updateTransportConfig | updateTransportConfig()}
-     * or replaced entirely with {@link setTransportConfig | setTransportConfig()}.
+     * via  Websockets is supported. The default network configuration can be
+     * modified with {@link updateTransportConfig | updateTransportConfig()}
+     * or replaced with {@link setTransportConfig | setTransportConfig()}.
      *
      * Performance of initial sync when bootstrapping new peers can be improved by
      * calling {@link disableSyncWithV3 | disableSyncWithV3()} before
@@ -9968,7 +10357,7 @@ class Ditto {
     /**
      * Stops all network transports.
      *
-     * You may continue to use the database locally but no data will sync to or
+     * You may continue to use the Ditto store locally but no data will sync to or
      * from other devices.
      *
      * @see {@link isSyncActive}
@@ -9993,7 +10382,9 @@ class Ditto {
     observePeers(callback) {
         Logger.warning('`ditto.observePeers()` is deprecated, please use `ditto.presence.observe()` instead.');
         const token = this.presenceManager.addObserver(callback);
-        return new Observer(this.presenceManager, token, { stopsWhenFinalized: true });
+        return new Observer(this.presenceManager, token, {
+            stopsWhenFinalized: true,
+        });
     }
     /**
      * Register observer for changes of underlying transport conditions.
@@ -10006,7 +10397,9 @@ class Ditto {
      */
     observeTransportConditions(callback) {
         const token = this.transportConditionsManager.addObserver(callback);
-        return new Observer(this.transportConditionsManager, token, { stopsWhenFinalized: true });
+        return new Observer(this.transportConditionsManager, token, {
+            stopsWhenFinalized: true,
+        });
     }
     /**
      * Removes all sync metadata for remote peers that aren't currently connected.
@@ -10042,7 +10435,8 @@ class Ditto {
      * This improves performance of initial sync when this peer has never before
      * connected to a Ditto mesh for which sync with v3 peers is disabled.
      *
-     * @throws {Error} if called in a React Native environment.
+     * @throws {Error} when called in a React Native environment where sync with v3
+     * is always disabled.
      */
     async disableSyncWithV3() {
         return this.deferCloseAsync(async (dittoHandle) => {
@@ -10056,9 +10450,8 @@ class Ditto {
      * persistence directory.
      */
     async close() {
-        if (this.isClosed) {
+        if (this.isClosed)
             return;
-        }
         this._isClosed = true;
         this.stopSync();
         this.store.close();
@@ -10075,14 +10468,15 @@ class Ditto {
         }
         // Await all pending operations before closing. Rejected promises are
         // ignored because they are handled at the original call site.
-        do {
+        do
             await Promise.allSettled(this.pendingOperations);
-            // REFACTOR: in theory, we could end up in an endless loop here if for
-            // some reason a resolved or rejected promise isn't removed from
-            // `pendingOperations`. AFAICS, this is not possible atm due to the
-            // way `deferClose` and `deferCloseAsync` is implemented. Would be
-            // great to rework this and make it more solid if possible.
-        } while (this.pendingOperations.size > 0);
+        while (
+        // REFACTOR: in theory, we could end up in an endless loop here if for
+        // some reason a resolved or rejected promise isn't removed from
+        // `pendingOperations`. AFAICS, this is not possible atm due to the
+        // way `deferClose` and `deferCloseAsync` is implemented. Would be
+        // great to rework this and make it more solid if possible.
+        this.pendingOperations.size > 0);
         this.deferCloseAllowed = false;
         await Bridge.ditto.close(this);
     }
@@ -10155,26 +10549,45 @@ class Ditto {
         this.isX509Valid = isX509Valid;
         this.isWebValid = isWebValid;
         this.auth['@ditto.authClientValidityChanged'](isWebValid, isX509Valid);
-        this.sync.update({ transportConfig, identity, isWebValid, isX509Valid, isSyncActive, ditto: this });
+        this.sync.update({
+            transportConfig,
+            identity,
+            isWebValid,
+            isX509Valid,
+            isSyncActive,
+            ditto: this,
+        });
     }
     validateIdentity(identity) {
         const validIdentity = { ...identity };
         // @ts-expect-error we validate the existence of the value below.
         const appID = identity.appID;
-        if (!['offlinePlayground', 'sharedKey', 'manual', 'onlinePlayground', 'onlineWithAuthentication'].includes(identity.type)) {
+        if (![
+            'offlinePlayground',
+            'sharedKey',
+            'manual',
+            'onlinePlayground',
+            'onlineWithAuthentication',
+        ].includes(identity.type)) {
             throw new Error(`Can't create Ditto instance, unknown identity type: ${identity.type}`);
         }
-        if ((identity.type === 'offlinePlayground' || identity.type === 'sharedKey' || identity.type === 'onlinePlayground' || identity.type === 'onlineWithAuthentication') && typeof appID === 'undefined') {
+        if ((identity.type === 'offlinePlayground' ||
+            identity.type === 'sharedKey' ||
+            identity.type === 'onlinePlayground' ||
+            identity.type === 'onlineWithAuthentication') &&
+            typeof appID === 'undefined')
             throw new Error(`Property .appID must be given for identity, but isn't.`);
-        }
         if (typeof appID !== 'undefined' && typeof appID !== 'string') {
             throw new Error(`Property .appID must be be of type string, but is of type '${typeof appID}': ${appID}`);
         }
-        if ((identity.type === 'offlinePlayground' || identity.type === 'sharedKey') && typeof identity.siteID !== 'undefined') {
+        if ((identity.type === 'offlinePlayground' ||
+            identity.type === 'sharedKey') &&
+            typeof identity.siteID !== 'undefined') {
             const siteID = identity.siteID;
             const isSiteIDNumberOrBigInt = typeof siteID === 'number' || typeof siteID === 'bigint';
-            if (!isSiteIDNumberOrBigInt)
+            if (!isSiteIDNumberOrBigInt) {
                 throw new Error("Can't create Ditto instance, siteID must be a number or BigInt");
+            }
             if (siteID < 0)
                 throw new Error("Can't create Ditto instance, siteID must be >= 0");
             if (siteID > BigInt('0xffffffffffffffff'))
@@ -10196,36 +10609,40 @@ class Ditto {
     }
     setSyncActive(flag) {
         this.deferClose((dittoHandle) => {
-            if (flag && IdentityTypesRequiringOfflineLicenseToken.includes(this.identity.type) && !this.isActivated) {
+            if (flag &&
+                IdentityTypesRequiringOfflineLicenseToken.includes(this.identity.type) &&
+                !this.isActivated) {
                 throw new Error('Sync could not be started because Ditto has not yet been activated. This can be achieved with a successful call to `setOfflineOnlyLicenseToken`. If you need to obtain a license token then please visit https://portal.ditto.live.');
             }
-            if (!this.isSyncActive && flag) {
+            if (!this.isSyncActive && flag)
                 this.keepAlive.retain('sync');
-            }
-            if (this.isSyncActive && !flag) {
+            if (this.isSyncActive && !flag)
                 this.keepAlive.release('sync');
-            }
             this._isSyncActive = flag;
             const isWebValid = this.isWebValid;
             const isX509Valid = this.isX509Valid;
             const identity = this.identity;
             const transportConfig = this.transportConfig;
             this._deviceName = dittoSetDeviceName(dittoHandle.deref(), this.deviceName);
-            this.sync.update({ identity, transportConfig, isWebValid, isX509Valid, isSyncActive: !!flag, ditto: this });
+            this.sync.update({
+                identity,
+                transportConfig,
+                isWebValid,
+                isX509Valid,
+                isSyncActive: !!flag,
+                ditto: this,
+            });
         });
     }
     makeDefaultTransportConfig() {
         return this.deferClose((dittoHandle) => {
             const transportConfig = new TransportConfig();
-            if (transportsBLEIsAvailable(dittoHandle.deref())) {
+            if (transportsBLEIsAvailable(dittoHandle.deref()))
                 transportConfig.peerToPeer.bluetoothLE.isEnabled = true;
-            }
-            if (transportsAWDLIsAvailable(dittoHandle.deref())) {
+            if (transportsAWDLIsAvailable(dittoHandle.deref()))
                 transportConfig.peerToPeer.awdl.isEnabled = true;
-            }
-            if (transportsLANIsAvailable(dittoHandle.deref())) {
+            if (transportsLANIsAvailable(dittoHandle.deref()))
                 transportConfig.peerToPeer.lan.isEnabled = true;
-            }
             return transportConfig.freeze();
         });
     }
@@ -10239,7 +10656,11 @@ class Ditto {
  * @internal
  */
 const checkAPIs = (_globalObject) => {
-    const requiredBrowserAPIs = ['BigInt', 'WeakRef', 'FinalizationRegistry'];
+    const requiredBrowserAPIs = [
+        'BigInt',
+        'WeakRef',
+        'FinalizationRegistry',
+    ];
     const globalObject = _globalObject || globalThis || global || window;
     return requiredBrowserAPIs.every((apiName) => !!globalObject[apiName]);
 };
@@ -10254,9 +10675,11 @@ const checkAPIs = (_globalObject) => {
 const disableDeadlockTimeoutWhenDebugging = () => {
     var _a, _b;
     {
-        const hasInspector = process && ((_a = process === null || process === void 0 ? void 0 : process.execArgv) === null || _a === void 0 ? void 0 : _a.some((arg) => arg.includes('--inspect') || arg.includes('--debug')));
-        // @ts-ignore - v8debug may be undefined
-        const hasLegacyDebugMode = (process && ((_b = process === null || process === void 0 ? void 0 : process.execArgv) === null || _b === void 0 ? void 0 : _b.some((arg) => arg.includes('--debug')))) || typeof v8debug === 'object';
+        const hasInspector = process &&
+            ((_a = process === null || process === void 0 ? void 0 : process.execArgv) === null || _a === void 0 ? void 0 : _a.some((arg) => arg.includes('--inspect') || arg.includes('--debug')));
+        const hasLegacyDebugMode = (process && ((_b = process === null || process === void 0 ? void 0 : process.execArgv) === null || _b === void 0 ? void 0 : _b.some((arg) => arg.includes('--debug')))) ||
+            // @ts-ignore - v8debug may be undefined
+            typeof v8debug === 'object';
         if (hasInspector || hasLegacyDebugMode) {
             try {
                 setDeadlockTimeout(0);
@@ -10353,9 +10776,8 @@ class QueryResultItem {
      */
     get value() {
         this.materialize();
-        if (this.materializedValue === undefined) {
+        if (this.materializedValue === undefined)
             throw new Error('Internal Error: Materialized value is undefined');
-        }
         return this.materializedValue;
     }
     /**
@@ -10444,12 +10866,10 @@ function getBridgeLoad() {
     const countsByType = {};
     Bridge.all.map((bridgeWeakRef) => {
         const bridge = bridgeWeakRef.deref();
-        if (!bridge) {
+        if (!bridge)
             return null;
-        }
-        if (bridge.count === 0) {
+        if (bridge.count === 0)
             return null;
-        }
         countsByType[bridge.type.name] = bridge.count;
     });
     return countsByType;